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.

ui/src/lib/mock/client.ts

@@ -34,7 +34,8 @@ import type {
   Variant,
   WordCheckResult,
 } from '../model';
-import { tileValue } from '../premiums';
+import { valueForLetter } from '../alphabet';
+import { seedMockAlphabets } from './alphabet';
 import {
   ME,
   MOCK_FRIENDS,
@@ -93,6 +94,12 @@ export class MockGateway implements GatewayClient {
   private invitations: Invitation[] = mockInvitations();
   private readonly stats: Stats = { ...MOCK_STATS };
 
+  constructor() {
+    // Seed the per-variant alphabet cache the rack, blank chooser and scoring read, so the
+    // mock-driven UI is alphabet-agnostic without a backend (Stage 13).
+    seedMockAlphabets();
+  }
+
   setToken(_token: string | null): void {
     // The mock needs no auth; the real transport stores the bearer token.
   }
@@ -174,7 +181,7 @@ export class MockGateway implements GatewayClient {
   }
 
   // --- game ---
-  async gameState(gameId: string): Promise<StateView> {
+  async gameState(gameId: string, _includeAlphabet: boolean): Promise<StateView> {
     const g = this.game(gameId);
     return {
       game: structuredClone(g.view),
@@ -190,12 +197,12 @@ export class MockGateway implements GatewayClient {
     return { gameId, moves: structuredClone(g.moves) };
   }
 
-  async submitPlay(gameId: string, dir: 'H' | 'V', tiles: PlacedTile[]): Promise<MoveResult> {
+  async submitPlay(gameId: string, dir: 'H' | 'V', tiles: PlacedTile[], _variant: Variant): Promise<MoveResult> {
     const g = this.game(gameId);
     const seat = this.mySeat(g);
     if (g.view.toMove !== seat) throw new GatewayError('not_your_turn');
     const variant = g.view.variant;
-    let score = tiles.reduce((s, t) => s + tileValue(variant, t.blank ? '?' : t.letter), 0);
+    let score = tiles.reduce((s, t) => s + valueForLetter(variant, t.blank ? '?' : t.letter), 0);
     if (tiles.length === 7) score += 50;
     const total = g.view.seats[seat].score + score;
     const move = {
@@ -265,7 +272,7 @@ export class MockGateway implements GatewayClient {
   pass(gameId: string): Promise<MoveResult> {
     return this.simpleAction(gameId, 'pass');
   }
-  exchange(gameId: string, tiles: string[]): Promise<MoveResult> {
+  exchange(gameId: string, tiles: string[], _variant: Variant): Promise<MoveResult> {
     return this.simpleAction(gameId, 'exchange', tiles);
   }
   resign(gameId: string): Promise<MoveResult> {
@@ -287,22 +294,22 @@ export class MockGateway implements GatewayClient {
         tiles: [{ row: 7, col: 7, letter, blank: false }],
         words: [letter],
         count: 1,
-        score: tileValue(g.view.variant, letter),
+        score: valueForLetter(g.view.variant, letter),
         total: 0,
       },
       hintsRemaining: g.hintsRemaining,
     };
   }
 
-  async evaluate(gameId: string, _dir: 'H' | 'V', tiles: PlacedTile[]): Promise<EvalResult> {
+  async evaluate(gameId: string, _dir: 'H' | 'V', tiles: PlacedTile[], _variant: Variant): Promise<EvalResult> {
     const g = this.game(gameId);
     if (tiles.length === 0) return { legal: false, score: 0, words: [] };
-    let score = tiles.reduce((s, t) => s + tileValue(g.view.variant, t.blank ? '?' : t.letter), 0);
+    let score = tiles.reduce((s, t) => s + valueForLetter(g.view.variant, t.blank ? '?' : t.letter), 0);
     if (tiles.length === 7) score += 50;
     return { legal: true, score, words: [tiles.map((t) => t.letter).join('')] };
   }
 
-  async checkWord(_gameId: string, word: string): Promise<WordCheckResult> {
+  async checkWord(_gameId: string, word: string, _variant: Variant): Promise<WordCheckResult> {
     return { word, legal: word.trim().length >= 2 };
   }
   async complaint(): Promise<void> {}