Stop a scalar created inside a scope costing value-pool slots

A scalar now lives in the variable record (`akbasic_Variable::inlinevalue`)
rather than drawing from the value pool, so a `GOSUB` local, a `FOR` counter and
a `DEF` parameter cost nothing at all.

The pool is a bump allocator with no free, and its comment justified that with
"nothing in BASIC destroys a variable". Scope exit does: it marks the variable
slot unused, `new_variable()` memsets the slot it hands back -- clearing
`values` -- and `variable_init()` therefore took *fresh* slots for a variable
whose old ones were still counted. Every scope that created a local leaked, with
no diagnostic until the pool ran dry on whichever line happened to be unlucky.

Six thousand `GOSUB`s creating one local used to die on the 4091st at `LOC# = 1`
with "Array of 1 elements does not fit in the 0 remaining value slots". They now
run. A `DEF` called eight thousand times used to die between the four and five
thousandth -- the leaking slot was the call scope's parameter, which is a scalar
-- and both forms now run. A game creating one name per tick was dead in half a
minute; the Breakout in examples/ was, after twenty-five seconds.

**A `@` name is the one exclusion, and it is the whole of it.** A structure or a
pointer to one keeps pool storage, because a pointer into a record outlives the
scope that DIMmed it -- docs/16-structures.md says nothing is reclaimed and
`prev_environment()` relies on it. The name suffix is the right test rather than
`structtype`, which the DIM path sets *after* calling `variable_init()`. A local
array therefore still leaks, deliberately, and is now the narrow rule the
tutorial teaches.

`SWAP` needed the other half: it copies whole variable records, so the `values`
pointer that came over named the other variable's inline slot -- which by then
held this variable's own old value -- and SWAP silently did nothing. Caught by
tests/language/housekeeping/verbs.bas, which is the golden corpus earning its
keep.

tests/value_pool.c is the new coverage. It asserts the mechanism as well as the
consequence: a later change that moved arrays inline too would pass every
behavioural case and quietly break the pointer guarantee. The sharpest case
takes the pool's whole 4096 slots in four arrays after two hundred scope
entries, so one leaked slot has nowhere to go.

Chapter 17 Step 3 taught "declare every name at the top" and no longer needs to.
It now teaches what is still true -- a name first seen inside a subroutine dies
at RETURN, so a routine cannot answer its caller through one -- and its
demonstration is the array case, which still fails.

TODO.md section 6 item 30 and section 9 item 1, both struck.

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

include/akbasic/value.h

@@ -21,17 +21,24 @@
 #include <akbasic/types.h>
 
 /*
- * Backing store for array variables. Scalars and arrays alike draw their storage
- * from here rather than from malloc, and a variable holds a pointer into it. The
- * runtime owns exactly one; it is passed explicitly rather than kept at file
- * scope, because the interpreter must be embeddable and may not own global
- * mutable state.
+ * Backing store for arrays and structures. They draw their storage from here
+ * rather than from malloc, and a variable holds a pointer into it. The runtime
+ * owns exactly one; it is passed explicitly rather than kept at file scope,
+ * because the interpreter must be embeddable and may not own global mutable
+ * state.
  *
- * The allocator is a bump: releasing is not supported, because nothing in BASIC
- * destroys a variable. Re-DIMming a variable to the same size or smaller reuses
- * its existing slice; growing it takes fresh slots and abandons the old ones. A
- * program that re-DIMs the same array larger in a loop will exhaust the pool and
- * get AKBASIC_ERR_BOUNDS -- bounded and diagnosable, which is the point.
+ * **A scalar is not in here.** It lives in the variable itself
+ * (akbasic_Variable::inlinevalue), because scope exit *does* destroy variables
+ * -- it returns the slot but not its storage -- and a bump allocator has no way
+ * to take a scalar back. See akbasic_variable_init().
+ *
+ * The allocator is a bump: releasing is not supported. Re-DIMming an array to
+ * the same size or smaller reuses its existing slice; growing it takes fresh
+ * slots and abandons the old ones. A program that re-DIMs the same array larger
+ * in a loop will exhaust the pool and get AKBASIC_ERR_BOUNDS -- bounded and
+ * diagnosable, which is the point. A local *array* therefore still costs slots
+ * that do not come back, which is the same statement and is deliberate: a
+ * pointer into a record outlives the scope that DIMmed it.
  */
 typedef struct
 {

include/akbasic/variable.h

@@ -20,8 +20,21 @@ typedef struct
 {
     char name[AKBASIC_MAX_STRING_LENGTH];
     akbasic_Type valuetype;
-    akbasic_Value *values;			/** Points into the runtime's value pool */
+    akbasic_Value *values;			/** The pool, or `inlinevalue` for a scalar */
     int valuecount;
+    /*
+     * A scalar's storage, so that creating one costs the value pool nothing.
+     *
+     * The pool is a bump allocator with no free, and a scope exit hands the
+     * variable *slot* back while its storage stays counted against the pool --
+     * so a name first created inside a GOSUB used to spend slots on every call
+     * and 4096 creations ended the run. Keeping the one value here instead
+     * means a local, a FOR counter and a DEF parameter are all free.
+     *
+     * akbasic_variable_init() decides which of the two `values` points at, and
+     * a `@` name is the one exclusion: see the comment there.
+     */
+    akbasic_Value inlinevalue;
     int64_t dimensions[AKBASIC_MAX_ARRAY_DEPTH];
     int dimensioncount;
     bool mutable_;