docs: restructure org for per-function literate prose

37 per-function code blocks with prose explaining design reasoning,
edge cases, and CL traps. Combined tangle blocks at end for actual
compilation.

New scripts/tangle.py: reliable Python tangler (emacs --batch failed).
Added: %split-string, %join-lines, tangle helper.

CL traps documented in org prose:
- defstruct generates keyword constructors (no :constructor needed)
- case with strings uses EQL — use cond + string=
- CL strings: no \n escape — use (string #\Newline)
- FiveAM closure capture — use list boxing
- read-byte is package-locked — use read-raw-byte
- ASDF compile-file stricter than LOAD — debug with LOAD

60 tests, 100% GREEN.

scripts/tangle.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""tangle.py — Extract code blocks from .org files into .lisp files.
+
+Reads all .org files in org/ directory, finds #+BEGIN_SRC lisp :tangle <path>
+blocks, and writes/concatenates them to the specified target paths.
+
+Blocks with the same :tangle target are concatenated in file order.
+
+Usage:
+  python3 scripts/tangle.py              # tangle all org/ files
+  python3 scripts/tangle.py org/specific.org  # tangle one file
+
+Target paths are relative to the project root (../target from org/ = project/target).
+"""
+import re
+import os
+import sys
+from collections import OrderedDict
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ORG_DIR = os.path.join(PROJECT_ROOT, 'org')
+
+def tangle_file(org_path):
+    """Extract tangle blocks from one .org file."""
+    with open(org_path) as f:
+        content = f.read()
+
+    # Find all tangle blocks with their targets
+    pattern = r'#\+BEGIN_SRC lisp :tangle ([^\n]+)\n(.*?)\n#\+END_SRC'
+    blocks = re.findall(pattern, content, re.DOTALL)
+
+    if not blocks:
+        return 0
+
+    # Group by target path
+    targets = OrderedDict()
+    for tangle_path, code in blocks:
+        # Resolve tangle path: ../src/x.lisp -> src/x.lisp
+        resolved = tangle_path.replace('../', '')
+        full_path = os.path.join(PROJECT_ROOT, resolved)
+        if full_path not in targets:
+            targets[full_path] = []
+        targets[full_path].append(code.strip())
+
+    for full_path, codes in targets.items():
+        os.makedirs(os.path.dirname(full_path), exist_ok=True)
+        combined = '\n\n'.join(codes) + '\n'
+        with open(full_path, 'w') as f:
+            f.write(combined)
+        print(f"  {os.path.relpath(full_path, PROJECT_ROOT)} ({len(codes)} blocks, {sum(len(c) for c in codes)} chars)")
+
+    return len(blocks)
+
+def main():
+    if len(sys.argv) > 1:
+        org_files = [f for f in sys.argv[1:] if f.endswith('.org')]
+    else:
+        org_files = [os.path.join(ORG_DIR, f) for f in os.listdir(ORG_DIR) if f.endswith('.org')]
+
+    total_blocks = 0
+    for org_file in sorted(org_files):
+        name = os.path.basename(org_file)
+        blocks = tangle_file(org_file)
+        if blocks:
+            print(f"{name}: {blocks} blocks")
+            total_blocks += blocks
+
+    if total_blocks > 0:
+        print(f"\nTotal: {total_blocks} code blocks tangled")
+    else:
+        print("No tangle blocks found.")
+
+if __name__ == '__main__':
+    main()