Version the library at 0.1.0

project() now carries VERSION 0.1.0, and is the single place a version number
is spelled. It flows into generated version macros, the shared library's
VERSION/SOVERSION, the Version: field in akstdlib.pc, and a new
akstdlibConfigVersion.cmake. Before this @PROJECT_VERSION@ expanded to
nothing, so akstdlib.pc shipped an empty Version: and libakstdlib.so carried
no soname at all.

0.x on purpose: TODO.md section 2.1 still records four confirmed defects whose
fixes change documented behaviour, so the API is not being promised yet. While
the major version is 0 the soname carries MAJOR.MINOR -- 0.1 and 0.2 are
different ABIs -- and becomes MAJOR alone at 1.0. The if() in CMakeLists.txt
and the #if in tests/test_version.c encode that rule and are tested against
each other.

include/akstdlib_version.h.in is configured into the build tree as
akstdlib_version.h and installed beside akstdlib.h. It defines
AKSL_VERSION_MAJOR/MINOR/PATCH/STRING/NUMBER and AKSL_VERSION_SONAME.
AKSL_VERSION_NUMBER is computed rather than written as a literal, because a
literal 000100 is octal in C and would make 0.1.0 compare as 64;
test_version.c asserts it against the runtime components, so a rewrite to a
literal fails.

Those macros record what a caller was compiled against. aksl_version(),
aksl_version_string() and aksl_version_soname() report what actually loaded,
and AKSL_VERSION_CHECK() compares the two, raising AKERR_VALUE naming both.
It is a macro so that it expands at the caller's site and captures the
caller's numbers; the function compares them against the ones baked into the
library. Compatibility is "same soname", so patch is ignored -- a caller built
against 0.1.0 keeps working against 0.1.7.

Normally the soname catches a mismatch at load time and the check never fires.
It earns its keep when the soname is bypassed: a 0.2.0 build dropped in under
the 0.1 filename loads happily, and only the check notices.

write_basic_package_version_file() uses SameMinorVersion to mirror the soname,
falling back to ExactVersion below CMake 3.11 where that mode does not exist.
The fallback is stricter than the soname rule -- it pins the patch level too --
but never laxer, and wrongly refusing a good pairing beats wrongly accepting a
bad one.

Coverage of src/stdlib.c rose to 99.1% of lines (217/219), 45.1% of branches
and 25/25 functions. That puts branch coverage back over the old 45 gate, but
the gate stays at 40: 0.1 points of headroom is not a ratchet.

ctest 14/14, ASan+UBSan 14/14, coverage 16/16 at 90/40. Also verified out of
tree: SONAME libakstdlib.so.0.1 recorded in consumers, pkg-config
--modversion reporting 0.1.0, find_package(akstdlib 0.1) accepted with 0.2 and
1.0 refused, a patch-bumped 0.1.1 loading and passing the check, a 0.2.0
dropped in under the 0.1 filename caught by it, and an embedded
add_subdirectory build keeping its own version rather than the parent's.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/stdlib.c

@@ -6,6 +6,57 @@
 #include <stdarg.h>
 #include <stdint.h>
 
+/*
+ * Version of the library itself. These read the AKSL_VERSION_* macros as they
+ * were when *this translation unit* was compiled, which is what makes them the
+ * loaded library's version rather than the caller's: the caller's copy of the
+ * same macros comes from whatever akstdlib_version.h it compiled against.
+ */
+akerr_ErrorContext AKERR_NOIGNORE *aksl_version(int *major, int *minor, int *patch)
+{
+    PREPARE_ERROR(e);
+    FAIL_ZERO_RETURN(e, major, AKERR_NULLPOINTER, "major=%p, minor=%p, patch=%p",
+		     (void *)major, (void *)minor, (void *)patch);
+    FAIL_ZERO_RETURN(e, minor, AKERR_NULLPOINTER, "major=%p, minor=%p, patch=%p",
+		     (void *)major, (void *)minor, (void *)patch);
+    FAIL_ZERO_RETURN(e, patch, AKERR_NULLPOINTER, "major=%p, minor=%p, patch=%p",
+		     (void *)major, (void *)minor, (void *)patch);
+    *major = AKSL_VERSION_MAJOR;
+    *minor = AKSL_VERSION_MINOR;
+    *patch = AKSL_VERSION_PATCH;
+    SUCCEED_RETURN(e);
+}
+
+const char *aksl_version_string(void)
+{
+    return AKSL_VERSION_STRING;
+}
+
+const char *aksl_version_soname(void)
+{
+    return AKSL_VERSION_SONAME;
+}
+
+/*
+ * Compatibility is "same soname". Pre-1.0 that is MAJOR.MINOR, so both are
+ * compared and patch is deliberately ignored; from 1.0 the minor comparison
+ * comes out, in step with the SOVERSION expression in CMakeLists.txt. The
+ * caller's numbers arrive as arguments because AKSL_VERSION_CHECK() expanded
+ * them at the caller's site -- see the macro in akstdlib.h.
+ */
+akerr_ErrorContext AKERR_NOIGNORE *aksl_version_check(int major, int minor, int patch)
+{
+    PREPARE_ERROR(e);
+    (void)patch;
+    FAIL_NONZERO_RETURN(e,
+			(major != AKSL_VERSION_MAJOR || minor != AKSL_VERSION_MINOR),
+			AKERR_VALUE,
+			"compiled against libakstdlib %d.%d.%d, loaded %s (soname %s)",
+			major, minor, patch,
+			AKSL_VERSION_STRING, AKSL_VERSION_SONAME);
+    SUCCEED_RETURN(e);
+}
+
 akerr_ErrorContext AKERR_NOIGNORE *aksl_malloc(size_t size, void **dst)
 {
     PREPARE_ERROR(e);