Stage 13: alphabet on the wire (UI alphabet-agnostic, TODO-4)

Live play now exchanges per-variant alphabet indices instead of concrete
letters (rack out; submit-play, evaluate, exchange, word-check in). The client
caches each variant's (index, letter, value) table behind
StateRequest.include_alphabet and renders the rack and blank chooser from it,
dropping the hardcoded value/alphabet tables. History, the durable journal and
GCG stay decoded concrete characters (ARCHITECTURE §9.1, unchanged).

- pkg/fbs: new AlphabetEntry + PlayTile; StateView.rack -> [ubyte] + alphabet;
  StateRequest.include_alphabet; SubmitPlay/Eval tiles -> [PlayTile];
  Exchange tiles + CheckWord word -> [ubyte] (committed Go + TS regenerated).
- engine: AlphabetTable + a cached per-variant codec (LetterForIndex/EncodeRack/
  DecodeTiles/DecodeWord) + BlankIndex sentinel; Go parity test.
- backend server edge maps index<->letter (new thin game.Service.GameVariant);
  game.Service domain methods, engine.Game and the robot keep one letter-based
  play path. The gateway forwards indices verbatim (no alphabet table).
- ui: lib/alphabet.ts in-memory cache; codec encodes/decodes indices; premiums.ts
  is geometry-only; the mock seeds a fixture table; the UI normalises display to
  upper case (codec + cache), leaving placement/board/checkword unchanged.

Parity moved to the Go engine.AlphabetTable test; premiums.ts loses its value
tables. Discharges TODO-4.

docs/ARCHITECTURE.md

@@ -87,6 +87,18 @@ dropped). Horizontal scaling is explicit future work.
   operation's domain outcome rides back in `ExecuteResponse.result_code` (HTTP
   200); only edge failures (rate limit, missing session, unknown type, internal)
   surface as Connect error codes.
+- **Alphabet on the wire (Stage 13)**: live play exchanges **alphabet indices**, not
+  concrete letters. The rack (`StateView.rack`), the `SubmitPlay`/`Evaluate` tiles, the
+  `Exchange` tiles and the `CheckWord` word are `ubyte` indices into the variant's alphabet
+  (a blank is the sentinel index **255**). The client is **alphabet-agnostic**: on a
+  per-variant cache miss it sets `StateRequest.include_alphabet`, and the backend embeds the
+  variant's `(index, letter, value)` table (`engine.AlphabetTable`, derived from the solver
+  ruleset — no dictionary) for display; the client caches it by variant and renders the rack
+  and the blank chooser from it. The backend maps index↔letter at its REST edge, so the
+  gateway forwards indices **verbatim** (it holds no alphabet table) and the engine's
+  letter-based domain API — shared with the robot — is unchanged. The table is pinned by the
+  solver version, so it cannot drift from the running backend. The **move journal, history
+  and GCG are unaffected** (they stay decoded concrete characters, §9.1).
 - **gateway ↔ backend (sync)**: plain HTTP REST/JSON. The gateway injects
   `X-User-ID` for authenticated requests; `backend` never re-derives identity
   from the body.
@@ -407,6 +419,11 @@ does not cover. **GCG export is offered only on a finished game** (`game.ErrGame
 otherwise, Stage 8), so an in-progress journal is never leaked mid-play; the client
 shares the `.gcg` file via the Web Share API where available, else downloads it.
 
+The Stage 13 alphabet-on-the-wire change does **not** touch this invariant: the live edge
+exchanges alphabet indices, but the persisted journal (and everything derived from it —
+replay, history, GCG) keeps the decoded concrete letters described above, so an archived
+game still replays with the variant's `rules.Alphabet` alone, independent of any dictionary.
+
 ## 10. Notifications
 
 Two channels: the **in-app live stream** (delivered from Stage 6) and