Give every exported function a declaration, and check that it stays that way

Closes internal-consistency items 7 through 15. Nineteen non-static functions
were in the ABI with no declaration anywhere, so no consumer could call them
and any consumer could collide with them.

The four gamepad_handle_* functions are the ones that mattered: controller.h
declared akgl_controller_handle_button_down and three siblings that did not
exist, so anything compiled against the header alone failed to link. The
definitions carry the declared names now, which also closes Defects -> Known
and still open item 10, and their documentation moved to the header.

The rest are either declared under a "part of the internal API" block --
akgl_game_save_actors and akgl_game_load_versioncmp, which tests/game.c had to
declare for itself, plus six tilemap loader helpers the untested-loader work
wants to reach -- or static, which is what the four save iterators and
load_objectnamemap should always have been. akgl_path_relative_from is deleted:
declared nowhere, called from nowhere, never wrote its output, and leaked a
pooled string on every call, so it closes Known and still open item 4 and item
40 by ceasing to exist.

scripts/check_api_surface.sh keeps it closed. It reads the built library's
dynamic symbol table and every public header with comments stripped, and fails
on an exported akgl_* symbol that is declared nowhere. Stripping comments is
the whole point -- four of these were mentioned in controller.h prose, which is
how they went unnoticed.

The pool-size ceilings are defined once, in heap.h, so the #ifndef override
hook fires for the first time; actor.h, sprite.h and character.h were defining
the same four unconditionally from headers heap.h includes above its own guard.
tests/header_pool_override.c fails the compile if that regresses.

Also here: (void) rather than () on the twelve no-argument entry points,
AKERR_NOIGNORE only on declarations, static helpers with the akgl_ prefix
dropped, and the six parameter-name mismatches. akgl_get_json_with_default had
its two contexts swapped rather than merely misspelled -- the incoming one was
`err` and its own was `e`, which is the name reserved for an incoming one.

24/24 pass, reindent --check clean.

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

src/json_helpers.c

@@ -57,7 +57,7 @@ akerr_ErrorContext *akgl_get_json_number_value(json_t *obj, char *key, float *de
     SUCCEED_RETURN(errctx);
 }
 
-akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_double_value(json_t *obj, char *key, double *dest)
+akerr_ErrorContext *akgl_get_json_double_value(json_t *obj, char *key, double *dest)
 {
     PREPARE_ERROR(errctx);
     FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL pointer reference");
@@ -146,25 +146,28 @@ akerr_ErrorContext *akgl_get_json_array_index_string(json_t *array, int index, a
     SUCCEED_RETURN(errctx);
 }
 
-akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_with_default(akerr_ErrorContext *err, void *defval, void *dest, uint32_t defsize)
+akerr_ErrorContext *akgl_get_json_with_default(akerr_ErrorContext *e, void *defval, void *dest, uint32_t defsize)
 {
-    PREPARE_ERROR(e);
-    if ( err == NULL ) {
-	SUCCEED_RETURN(e);
+    // Two contexts, and the names now say which is which: `e` is the incoming
+    // one being inspected, `errctx` is this function's own. They were `err` and
+    // `e`, which put the incoming context under the name the convention
+    // reserves for exactly that and the local one under a name that reads like
+    // it.
+    PREPARE_ERROR(errctx);
+    if ( e == NULL ) {
+	SUCCEED_RETURN(errctx);
     }
-    int docopy = 0;
 
-    FAIL_ZERO_RETURN(e, err, AKERR_NULLPOINTER, "err");
-    FAIL_ZERO_RETURN(e, defval, AKERR_NULLPOINTER, "defval");
-    FAIL_ZERO_RETURN(e, dest, AKERR_NULLPOINTER, "dest");
+    FAIL_ZERO_RETURN(errctx, defval, AKERR_NULLPOINTER, "defval");
+    FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "dest");
 
     ATTEMPT {
     } CLEANUP {
-    } PROCESS(err) {
-    } HANDLE_GROUP(err, AKERR_KEY) {
-    } HANDLE_GROUP(err, AKERR_INDEX) {
+    } PROCESS(e) {
+    } HANDLE_GROUP(e, AKERR_KEY) {
+    } HANDLE_GROUP(e, AKERR_INDEX) {
 	memcpy(dest, defval, defsize);
-    } FINISH(err, true);
+    } FINISH(e, true);
 
-    SUCCEED_RETURN(e);
+    SUCCEED_RETURN(errctx);
 }