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>

TODO.md

@@ -406,14 +406,19 @@ cue to move it into `AKSL_TESTS`.
 
 15. **`aksl_TreeNode.parent` is declared but never set or read** by any library function.
 
-16. **Header hygiene**: no `extern "C" { }` guard for C++ consumers; no version macros
-    (`AKSL_VERSION_MAJOR`…); `akstdlib.h` pulls in `stdio.h`/`stdlib.h`/`string.h`/`stdint.h`
-    into every consumer's namespace.
+16. **Header hygiene**: no `extern "C" { }` guard for C++ consumers; `akstdlib.h` pulls in
+    `stdio.h`/`stdlib.h`/`string.h`/`stdint.h` into every consumer's namespace. The version
+    macros this item also asked for are **done**: `AKSL_VERSION_MAJOR`/`_MINOR`/`_PATCH`/
+    `_STRING`/`_NUMBER`/`_SONAME` are generated into `akstdlib_version.h` from
+    `project(akstdlib VERSION …)`, with `aksl_version()`/`aksl_version_string()`/
+    `aksl_version_soname()` and `AKSL_VERSION_CHECK()` reporting the *loaded* library so a
+    header/`.so` mismatch is nameable. See `tests/test_version.c` and `README.md`.
 
-17. **Doxygen coverage is 2 functions out of 20.** A `Doxyfile` exists but only
+17. **Doxygen coverage is 2 functions out of 24.** A `Doxyfile` exists but only
     `aksl_tree_iterate` and `aksl_list_iterate` have doc comments. Every public function
     needs `@param`/`@throws`/`@return`, especially the ones whose contract deviates from libc
-    (`aksl_free(NULL)` is an error; `aksl_atoi` will become strict).
+    (`aksl_free(NULL)` is an error; `aksl_atoi` will become strict). The four
+    `aksl_version_*` entry points have prose comments in the header but no Doxygen tags.
 
 ### 2.3 Build, CI and repository
 
@@ -456,15 +461,26 @@ cue to move it into `AKSL_TESTS`.
       would mean testing libakerror's macros rather than this library; that belongs to
       libakerror's mutation suite, since macros expand at the call site and coverage cannot
       see them properly from either side. Revisit if the gap ever hides a real regression.
-- [ ] **`project()` declares no `VERSION`**, so `@PROJECT_VERSION@` expands to nothing and
-      the installed `akstdlib.pc` ships an empty `Version:` field — a consumer cannot pin
-      this library the way `akstdlib.pc` now pins `akerror >= 1.0.0`. libakstdlib also has
-      no `SOVERSION`, so `libakstdlib.so` carries no soname even though its public header
-      re-exports libakerror's ABI and therefore breaks whenever libakerror's does. Give the
-      project a version and a `SOVERSION`, and install an `akstdlibConfigVersion.cmake` via
-      `write_basic_package_version_file()` so `find_package(akstdlib 1.2 REQUIRED)` can work.
-      (libakerror has the same `ConfigVersion` gap, which is why
-      `cmake/akstdlib.cmake.in` calls `find_dependency(akerror)` with no version.)
+- [x] **`project()` declared no `VERSION`**, so `@PROJECT_VERSION@` expanded to nothing, the
+      installed `akstdlib.pc` shipped an empty `Version:` field, and `libakstdlib.so` carried
+      no soname. Now `project(akstdlib VERSION 0.1.0)`, with `SOVERSION` `0.1`
+      (`MAJOR.MINOR` while major is 0, `MAJOR` from 1.0 — the `if()` in `CMakeLists.txt` and
+      the matching `#if` in `tests/test_version.c` encode the rule and are tested against
+      each other), an `akstdlibConfigVersion.cmake` at `SameMinorVersion`, and version macros
+      generated into `akstdlib_version.h`. Verified: `find_package(akstdlib 0.1)` is accepted
+      while `0.2` and `1.0` are refused, and a 0.2.0 build dropped in under the 0.1 filename
+      is caught by `AKSL_VERSION_CHECK()`.
+- [ ] **libakerror still installs no `akerrorConfigVersion.cmake`**, so
+      `cmake/akstdlib.cmake.in` has to call `find_dependency(akerror)` with no version — a
+      request for one would be refused for want of a version file regardless of what is
+      installed. libakstdlib now does this correctly and libakerror does not; fix it there
+      with the same `write_basic_package_version_file()` call, then add the `1.0.0` floor to
+      the `find_dependency` here. Until then the floor rests on `akstdlib.pc`'s `Requires:`
+      and the `#error` guard in `akstdlib.h`.
+- [ ] **`aksl_version_check()` ignores its `patch` argument** (`src/stdlib.c`, the `(void)patch`),
+      which is correct for the current "same soname" rule but means the parameter exists only
+      so the error message can name the caller's full version. If a future rule needs patch
+      to participate, that is the line to change.
 - [ ] **CI does not build against the submodule it pins.** `.gitea/workflows/ci.yaml` clones
       `libakerror@main` and installs it, while the build it then runs is top-level and so
       compiles `deps/libakerror` at the pinned commit — two different libakerror versions