Document the interpreter's architecture as chapter fourteen

Chapters 1 through 13 describe the language. Nothing described the machine
that runs it, and the answers were spread across header comments, TODO.md
sections written for a different purpose, and the source itself. Somebody
embedding the interpreter, debugging something it did, or adding a verb had
to reconstruct the shape from all three.

docs/14-architecture.md is that shape, and only that: the three targets and
the driver, the single akbasic_Runtime and why nothing is file-scope,
akbasic_runtime_step() unrolled with the reason each stage sits where it
does, the four modes and what set_mode() does beyond assigning, a line's
journey from text through tokens and leaves to a verb handler, the dispatch
table, the pool map with what each exhaustion actually says, environments
doubling as block state, the two kinds of error, devices, and interrupts.

It defers rather than restates. The headers are the authority on every
function's contract and the chapter says so up front; where a rule is subtle
the header comment already states it at more length than a chapter should.
MAINTENANCE.md keeps the conventions and now points here for the mechanism,
so there is still one copy of each.

Two sections are the reason it exists at all. Debugging: reading a TRON trace
as evidence about the loop rather than the lines, reading an akerror stack
trace and what it is not, four breakpoints and the expressions worth printing
at them, narrowing with ctest -R and the mock devices, and a symptom-to-cause
table. Changing it: the verb recipe end to end including the private
src/verbs.h prototype that is easy to miss, the rule that a missing
dependency capability gets filed upstream rather than worked around, and the
five constraints goal 3 puts on any change.

A `text` fence tag comes with it. Every fenced block in docs/ is executed and
an untagged one is a hard error, so six block diagrams had nowhere to live.
The tag means never executed, it is counted in the skip line like `cmake`,
and MAINTENANCE.md documents it -- the alternative was an indented block the
extractor never sees, and a picture nobody decided about is indistinguishable
from a test nobody ran.

tests/docs_examples.sh now makes --root and --basic absolute before it
starts. Both are used from inside a sandbox directory it cd's into, so the
invocation MAINTENANCE.md itself documents -- --root . --basic ./build/basic
-- failed every example with "exited 127" and every setup= with "setup
failed". CTest passes absolute paths and never saw it; running one document
by hand hits it immediately.

Writing the error section turned up a defect and TODO.md section 8 records
it. The ATTEMPT blocks that turn a script's mistake into an error line wrap
parsing and interpretation but not scanning, so a line with more than 32
tokens escapes as an interpreter error: stack trace, exit 1, and at a prompt
the REPL is gone. That is the same shape as section 8 item 2, on a path that
fix did not cover. Not fixed here -- it is a behaviour change and wants its
own tests -- but written down with the three call sites and what would cover
them.

Both configurations stay green: 95/95 and 94/94. docs_examples now runs 37
programs, 9 transcripts, 45 output comparisons, 3 C snippets, 2 excerpts and
2 shell blocks, and skips 9 text blocks.

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

tests/docs_examples.sh

@@ -33,6 +33,7 @@
 #   ```sh setup=NAME      the same, after tests/docs_setups/NAME.sh
 #   ```sh norun           destructive, networked, or re-enters this suite
 #   ```cmake              never executed; hand-maintained, by decision
+#   ```text               a diagram or a captured dump; there is nothing to execute
 #
 # A block with **no** info string is a hard error. That is deliberate: the
 # failure mode this whole harness exists to avoid is passing because it quietly
@@ -76,7 +77,19 @@ done
 [ -n "${BASIC}" ] || usage
 [ -x "${BASIC}" ] || { echo "FAIL: no interpreter at ${BASIC}" >&2; exit 2; }
 
+# Both of these are used from inside a sandbox directory this script cd's into,
+# so a relative one silently resolves against the wrong place: `--basic
+# ./build/basic` fails every example with "exited 127", and `--root .` cannot
+# find tests/docs_setups. CTest passes absolute paths and never saw it; a person
+# running one document by hand hits it immediately. Resolve them here instead of
+# documenting the trap.
+case "${BASIC}" in
+/*) ;;
+*)  BASIC="${PWD}/${BASIC}" ;;
+esac
+
 cd "${ROOT}" || exit 2
+ROOT="${PWD}"
 
 DOCS=("$@")
 if [ ${#DOCS[@]} -eq 0 ]; then
@@ -116,7 +129,7 @@ CC="${CC:-cc}"
 
 FAILURES=0
 declare -A RAN=([basic]=0 [repl]=0 [output]=0 [c]=0 [excerpt]=0 [sh]=0)
-declare -A SKIPPED=([norun]=0 [akgl]=0 [cmake]=0 [nocc]=0)
+declare -A SKIPPED=([norun]=0 [akgl]=0 [cmake]=0 [text]=0 [nocc]=0)
 
 # Every failure names the file and line of the block, so the message points at
 # the thing to edit rather than at this script.
@@ -490,6 +503,12 @@ for DOC in "${DOCS[@]}"; do
 	cmake)
 	    SKIPPED[cmake]=$((SKIPPED[cmake] + 1))
 	    ;;
+	# A block diagram, or a stack trace captured from a real run. There is no
+	# executable claim in either, so the tag exists to say that out loud rather
+	# than to let one sit here untagged and unnoticed.
+	text)
+	    SKIPPED[text]=$((SKIPPED[text] + 1))
+	    ;;
 	"")
 	    fail "${WHERE}" "fenced block with no info string; tag it (see MAINTENANCE.md)"
 	    ;;
@@ -504,7 +523,7 @@ done
 # a chapter stopped matching the extractor looks exactly like a harness that
 # passes because the documentation is correct, and this is what tells them apart.
 echo "ran: ${RAN[basic]} programs, ${RAN[repl]} transcripts, ${RAN[output]} output comparisons, ${RAN[c]} C snippets, ${RAN[excerpt]} excerpts, ${RAN[sh]} shell blocks"
-echo "skipped: ${SKIPPED[norun]} norun, ${SKIPPED[akgl]} needing akgl, ${SKIPPED[cmake]} cmake, ${SKIPPED[nocc]} C (no compiler flags given)"
+echo "skipped: ${SKIPPED[norun]} norun, ${SKIPPED[akgl]} needing akgl, ${SKIPPED[cmake]} cmake, ${SKIPPED[text]} text, ${SKIPPED[nocc]} C (no compiler flags given)"
 
 if [ "${FAILURES}" -eq 0 ]; then
     echo "PASS: every documented example does what the documentation says"