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.

backend/internal/server/dto.go

@@ -101,13 +101,24 @@ type moveResultDTO struct {
 	Game gameDTO       `json:"game"`
 }
 
-// stateDTO is a player's view of a game.
+// alphabetEntryDTO is one letter of a variant's alphabet (its index, concrete letter and
+// tile value), embedded in the state view for display only when the client requests it
+// (Stage 13).
+type alphabetEntryDTO struct {
+	Index  int    `json:"index"`
+	Letter string `json:"letter"`
+	Value  int    `json:"value"`
+}
+
+// stateDTO is a player's view of a game. Rack carries wire alphabet indices (Stage 13; a
+// blank is engine.BlankIndex). Alphabet is present only when the request asked for it.
 type stateDTO struct {
-	Game           gameDTO  `json:"game"`
-	Seat           int      `json:"seat"`
-	Rack           []string `json:"rack"`
-	BagLen         int      `json:"bag_len"`
-	HintsRemaining int      `json:"hints_remaining"`
+	Game           gameDTO            `json:"game"`
+	Seat           int                `json:"seat"`
+	Rack           []int              `json:"rack"`
+	BagLen         int                `json:"bag_len"`
+	HintsRemaining int                `json:"hints_remaining"`
+	Alphabet       []alphabetEntryDTO `json:"alphabet,omitempty"`
 }
 
 // matchDTO reports whether the caller has been paired into a game.
@@ -217,15 +228,32 @@ func moveResultDTOFrom(r game.MoveResult) moveResultDTO {
 	return moveResultDTO{Move: moveRecordDTOFrom(r.Move), Game: gameDTOFromGame(r.Game)}
 }
 
-// stateDTOFrom projects a player's state view into its DTO.
-func stateDTOFrom(v game.StateView) stateDTO {
-	return stateDTO{
+// stateDTOFrom projects a player's state view into its DTO, encoding the rack as wire
+// alphabet indices (Stage 13). When includeAlphabet is set it also embeds the variant's
+// display table, which the client caches per variant and renders the rack with.
+func stateDTOFrom(v game.StateView, includeAlphabet bool) (stateDTO, error) {
+	rack, err := engine.EncodeRack(v.Game.Variant, v.Rack)
+	if err != nil {
+		return stateDTO{}, err
+	}
+	dto := stateDTO{
 		Game:           gameDTOFromGame(v.Game),
 		Seat:           v.Seat,
-		Rack:           v.Rack,
+		Rack:           rack,
 		BagLen:         v.BagLen,
 		HintsRemaining: v.HintsRemaining,
 	}
+	if includeAlphabet {
+		tab, err := engine.AlphabetTable(v.Game.Variant)
+		if err != nil {
+			return stateDTO{}, err
+		}
+		dto.Alphabet = make([]alphabetEntryDTO, len(tab))
+		for i, e := range tab {
+			dto.Alphabet[i] = alphabetEntryDTO{Index: int(e.Index), Letter: e.Letter, Value: e.Value}
+		}
+	}
+	return dto, nil
 }
 
 // matchDTOFrom projects an enqueue/poll result into its DTO.