rename: uncommonlisp -> lumbda throughout the repo

Historical internal name "uncommonlisp" retired in favor of the
public name "lumbda" ahead of lumbda.com going live. Scope of
this commit:

Source files renamed:
  uncommonlisp.py                     -> lumbda.py
  asm/uncommonlisp.s                  -> asm/lumbda.s
  c/uncommonlisp.h                    -> c/lumbda.h
  whitepaper/uncommonlisp-whitepaper  -> whitepaper/lumbda-whitepaper (.rst + .pdf)

Binaries renamed (tracked ones; c/ was always gitignored):
  asm/uncommonlisp, asm/uncommonlisp-gc, asm/uncommonlisp.o,
  asm/uncommonlisp-gc.o                -> asm/lumbda(-gc)(.o)
  c/.gitignore                          -> ignores lumbda

Internal string updates (sed pass ordered longest-first):
  asm/uncommonlisp -> asm/lumbda
  c/uncommonlisp   -> c/lumbda
  uncommonlisp.py  -> lumbda.py
  UNCOMMONLISP_BIN -> LUMBDA_BIN (asm/test.sh env var)
  "uncommonlisp> " -> "lumbda> " (asm REPL prompt baked into binary)
  UNCOMMONLISP     -> LUMBDA (macros, comments)
  uncommonlisp     -> lumbda (prose)

Binary portal magic updated:
  "ULPORTAL" -> "LUMBDAB1"   # "Lumbda Binary v1"
Old portal files are not backward-compatible — this is a deliberate
break since it's the rename moment. S-expression portals already
carry their own ";; lumbda-portal v1" header and remain cleanly
versioned.

WHITEPAPER.pdf / WHITEPAPER.rst symlinks repointed to the renamed
files. Makefile's whitepaper target targets lumbda-whitepaper.pdf.

Not changed (intentional, separate phases):
  - Filesystem directory /home/fox/git/uncommonlisp itself
    (fox renames locally and the gitlab repo URL in a follow-up)
  - tests.py hardcoded cwd=/home/fox/git/uncommonlisp
    (matches the current on-disk location; will flip when the
    directory rename ships)
  - Git history (immutable; old commits still say uncommonlisp,
    which is correct — that's what they were)

Verified:
  137 asm no-GC + 137 asm GC + 571 Python + 83 C + 189 shared
  functional tests all pass under the new names.
  bench-gc-http (2000 req): all 4 cells behave as expected
  (cells 1/2 flat, 3 leaks, 4 bounded at 1 chunk).
  Python REPL, C REPL, asm REPL all start cleanly.

proof/benchmark.sh

@@ -1,10 +1,10 @@
 #!/bin/bash
-# benchmark.sh — Run EML proof in both Python and uncommonlisp, compare times
+# benchmark.sh — Run EML proof in both Python and lumbda, compare times
 #
 # Usage: cd proof && bash benchmark.sh
 
 echo "═══════════════════════════════════════════════════════════════"
-echo "EML Universality Proof — Benchmark: Python vs uncommonlisp"
+echo "EML Universality Proof — Benchmark: Python vs lumbda"
 echo "═══════════════════════════════════════════════════════════════"
 echo
 
@@ -13,9 +13,9 @@ echo "---"
 time python3 eml_proof.py
 echo
 
-echo ">>> uncommonlisp implementation (--fast = bytecode compiled)"
+echo ">>> lumbda implementation (--fast = bytecode compiled)"
 echo "---"
-time python3 ../uncommonlisp.py --fast eml_proof.lsp
+time python3 ../lumbda.py --fast eml_proof.lsp
 echo
 
 echo "═══════════════════════════════════════════════════════════════"

proof/benchmark_results.md

@@ -8,7 +8,7 @@ with constant 1 generates all elementary functions (arXiv:2603.21852v2).
 | Approach | Time | Guarantee | Friction |
 |----------|------|-----------|----------|
 | Python (numerical) | 0.04s | 1e-10 tolerance | Low |
-| uncommonlisp (numerical) | 59s | 1e-10 tolerance | High |
+| lumbda (numerical) | 59s | 1e-10 tolerance | High |
 | Lean 4 (formal proof) | 1.5s | kernel-verified | Medium |
 
 ## Analysis
@@ -16,7 +16,7 @@ with constant 1 generates all elementary functions (arXiv:2603.21852v2).
 **The formal proof is 40x faster than brute-force search and provides
 mathematical certainty instead of floating-point tolerance.**
 
-The numerical approaches (Python and uncommonlisp) perform O(N²) pairwise
+The numerical approaches (Python and lumbda) perform O(N²) pairwise
 enumeration of EML trees, evaluating at transcendental test points and
 comparing against target functions. This is MOAD-0001 at the proof layer:
 quadratic search friction where algebraic reasoning suffices.

proof/eml_proof.lsp

@@ -1,9 +1,9 @@
-;;; eml_proof.lsp — Verify EML universality in uncommonlisp
+;;; eml_proof.lsp — Verify EML universality in lumbda
 ;;;
 ;;; eml(x, y) = exp(x) - ln(y) generates all elementary functions.
 ;;; Reference: "All elementary functions from a single operator" (arXiv:2603.21852v2)
 ;;;
-;;; Run: python3 uncommonlisp.py --fast proof/eml_proof.lsp
+;;; Run: python3 lumbda.py --fast proof/eml_proof.lsp
 
 ;;; ═══════════════════════════════════════════════════════════════════
 ;;; EML operator and test infrastructure
@@ -35,7 +35,7 @@
 (define gamma 0.5772156649015329)
 (define apery 1.2020569031595943)
 
-(display "EML Universality Proof — uncommonlisp") (newline)
+(display "EML Universality Proof — lumbda") (newline)
 (display "eml(x, y) = exp(x) - ln(y)") (newline)
 (display "======================================================================") (newline)
 
@@ -118,7 +118,7 @@
 (display "----------------------------------------------------------------------") (newline)
 (display "  Key insight: ln(negative) = ln(|neg|) + iπ") (newline)
 (display "  From -1, ln(-1) = iπ, giving access to complex plane.") (newline)
-(display "  uncommonlisp uses real arithmetic; verifying the chain:") (newline)
+(display "  lumbda uses real arithmetic; verifying the chain:") (newline)
 (newline)
 
 ;; Verify the real-arithmetic building blocks that WOULD give complex access:

proof/eml_proof_in_lumbda.lsp

@@ -12,9 +12,9 @@
 ;;; that checks it live in the same file.
 ;;;
 ;;; Runs byte-identically in Python, C, and asm:
-;;;   python3 uncommonlisp.py --fast proof/eml_proof_in_lumbda.lsp
-;;;   ./c/uncommonlisp proof/eml_proof_in_lumbda.lsp
-;;;   ./asm/uncommonlisp < proof/eml_proof_in_lumbda.lsp
+;;;   python3 lumbda.py --fast proof/eml_proof_in_lumbda.lsp
+;;;   ./c/lumbda proof/eml_proof_in_lumbda.lsp
+;;;   ./asm/lumbda < proof/eml_proof_in_lumbda.lsp
 
 ;;; ═══════════════════════════════════════════════════════════════
 ;;; Term-rewriting engine