Execute every documented example as a test

docs/ and README.md carry 85 fenced blocks. Every one was checked by hand
exactly once, when it was written, which is not a standard that survives a
changing interpreter -- and four were already wrong: two transcripts showing a
leading space PRINT does not emit, akbasic_TextSink in README.md missing the
two members it had grown hours earlier, and FILTER's refusal quoted with
wording the code does not use.

tests/docs_examples.sh reads a fence-tag vocabulary and runs what it finds.
BASIC programs and transcripts run and are byte-compared against an `output`
block; C snippets compile with -fsyntax-only against the real include path,
which CMake writes out because it is transitive through akerror, akstdlib and
akgl; shell blocks run in a sandbox. Anything that would reconfigure the build
tree, hit the network or re-enter the suite is tagged norun with the reason in
MAINTENANCE.md, and the two cmake blocks stay hand-maintained by decision.

An untagged block is a failure rather than a default, and the pass line
reports what it executed by kind. Both exist because the way a harness like
this dies is by quietly matching nothing and passing -- which it duly did on
the first CTest run, where a generator expression evaluating to nothing still
contributed an empty argument that the script read as a filename. The count is
what caught it.

The excerpt check earns its own mention: a block tagged
`c excerpt=include/akbasic/sink.h` must still appear in that header, comments
and whitespace ignored. Compiling it would only redefine the type, so a
compile check could not have found the stale struct, and did not.

Registered as the CTest case docs_examples in both configurations. Fixing the
four wrong examples turned up two interpreter defects, fixed in the previous
commit and recorded in TODO.md section 8.

MAINTENANCE.md is new: the fence-tag reference, what to do when the case
fails, and the conventions that until now only existed inside source comments
-- the three test lists and how two of them invert "passed", the sorted verb
table, that a golden file is never edited to suit this interpreter, and that a
fix gets mutation-checked with a file copy rather than git checkout.

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

docs/03-the-language.md

@@ -11,7 +11,7 @@ a character that says what it holds:
 | `%` | floating point | `RATE%`, `X%` |
 | `$` | string | `NAME$` |
 
-```
+```basic
 10 COUNT# = 42
 20 RATE% = 1.5
 30 NAME$ = "ADA"
@@ -31,9 +31,12 @@ Variable names are **case sensitive**. Verb and function names are not: `print`,
 
 Integers are 64-bit. Floats are IEEE doubles, so they print with six decimal places:
 
-```
+```basic repl
 PRINT 1.5
- 1.500000
+```
+
+```output
+1.500000
 ```
 
 Literals may be written in hexadecimal with a `0x` prefix. A leading zero is *not*
@@ -47,16 +50,22 @@ escaping: a string cannot contain a double quote.
 
 `+` concatenates, and it will concatenate a string with a number:
 
-```
+```basic repl
 PRINT "COUNT: " + 42
- COUNT: 42
+```
+
+```output
+COUNT: 42
 ```
 
 `*` repeats:
 
-```
+```basic repl
 PRINT "-" * 20
- --------------------
+```
+
+```output
+--------------------
 ```
 
 ## Arrays
@@ -64,12 +73,16 @@ PRINT "-" * 20
 `DIM` makes one. Subscripts start at zero and the number you give is the *count*, so
 `DIM A#(3)` gives you `A#(0)` through `A#(2)`:
 
-```
+```basic
 10 DIM A#(3)
 20 A#(0) = 10 : A#(1) = 20 : A#(2) = 30
 30 PRINT A#(0) + A#(1) + A#(2)
 ```
 
+```output
+60
+```
+
 Arrays can have several dimensions: `DIM GRID#(10, 10)`. `LEN(A#)` gives the total
 number of elements.
 
@@ -93,7 +106,7 @@ In order of precedence, tightest first:
 
 Both mean equality **inside a condition**:
 
-```
+```basic norun
 10 IF A# = 5 THEN PRINT "FIVE"
 20 IF A# == 5 THEN PRINT "ALSO FIVE"
 ```
@@ -108,20 +121,26 @@ and the reason `AND` and `OR` double as the logical operators: -1 is every bit s
 
 Anything non-zero is true, so `IF A# THEN ...` works:
 
-```
+```basic
 10 A# = 5
 20 IF A# THEN PRINT "NON-ZERO IS TRUE"
 30 IF A# = 5 AND A# > 1 THEN PRINT "AND WORKS"
 40 IF NOT (A# = 9) THEN PRINT "SO DOES NOT"
 ```
 
+```output
+NON-ZERO IS TRUE
+AND WORKS
+SO DOES NOT
+```
+
 `AND` and `OR` are still bitwise on ordinary numbers: `PRINT 12 AND 10` gives `8`.
 
 ## Comments
 
 `REM` comments to the end of the line.
 
-```
+```basic
 10 REM This does nothing at all
 ```
 
@@ -129,20 +148,28 @@ Anything non-zero is true, so `IF A# THEN ...` works:
 
 `DEF` makes a single-expression function:
 
-```
+```basic
 10 DEF SQUARE(X#) = X# * X#
 20 PRINT SQUARE(7)
 ```
 
+```output
+49
+```
+
 A multi-line definition runs until `RETURN`, which is how you write a subroutine that
 takes arguments:
 
-```
+```basic
 10 DEF GREET(N$)
 20   PRINT "HELLO, " + N$
 30   RETURN 0
 40 X# = GREET("WORLD")
 ```
 
+```output
+HELLO, WORLD
+```
+
 `RETURN` carries the value back, so a multi-line `DEF` is a function even when you only
 wanted the effect — assign the result somewhere to throw it away.