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>

TODO.md

@@ -1558,6 +1558,34 @@ fix is reverted:
 Neither was on any list. Both were found by writing down what a chapter claimed and then
 running it — which is the argument for the harness rather than a footnote to it.
 
+**A third is open, and it is the same defect as item 2 on a path that fix did not cover.**
+Writing `docs/14-architecture.md` meant describing where the boundary between a script's
+error and the host's error actually sits, and the answer is: around parsing and around
+`interpret()`, but **not around scanning**. `akbasic_runtime_process_line_repl()` and
+`akbasic_runtime_process_line_run()` both call `akbasic_scanner_scan()` under a bare `PASS`
+(`src/runtime.c:825` and `:921`), so any error the scanner raises leaves `step()` as an
+interpreter error. The reachable one is the token ceiling:
+
+```sh norun
+$ printf 'PRINT 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1\n' | ./build/basic
+src/scanner.c:add_token:87: 515 (Out Of Bounds) : Line 0 has more than 32 tokens
+... eight more frames ...
+akbasic terminated on an unhandled error 515 (Out Of Bounds)
+```
+
+Exit status 1, a stack trace on stderr, and the prompt gone — for a line a person typed. An
+embedding host is handed a context for what is plainly the script's mistake, which is what
+goal 3 exists to prevent. It should print `? N : PARSE ERROR Line N has more than 32 tokens`
+and stop the run, exactly as a parse error does two lines further down.
+
+The fix is the same `ATTEMPT`/`HANDLE_DEFAULT`/`akbasic_runtime_error()` wrapper already
+sitting around `akbasic_parser_parse()` in both functions, moved up to cover the scan.
+Three call sites to check, because `process_line_runstream()` has the same bare `PASS` and
+its answer may want to differ: a bad line arriving from a file mid-load is not the same
+situation as one typed at a prompt. Wants a test in `tests/scanner_tokens.c` asserting the
+error line rather than the raised status, and one in `tests/housekeeping_verbs.c` asserting
+the REPL survives it — the shape item 2's test already has.
+
 Coverage of the verb groups added for goal 2, since they are the new surface: `src/audio_tables.c`
 and `src/graphics_tables.c` 100%, `src/runtime_input.c` 100%, `src/runtime_graphics.c` and
 `src/runtime_audio.c` 98%, `src/play.c` 87%. The `akbasic_akgl` target is not in the coverage