Stage 3: game domain (lifecycle, journal+cache, hint, word-check, GCG, stats)

internal/game drives the engine over a single match and owns everything the
engine does not: event-sourced persistence (a games row + an append-only decoded
move journal, with the live engine.Game kept warm in a cache and rebuilt by
replay on a miss), the play/pass/exchange/resign transitions with
validate-at-submit scoring, an unlimited score/legality preview, the hint
(per-game allowance + profile wallet), the word-check tool with complaint
capture, per-player game state, history and GCG export (Poslfit dialect), and a
background turn-timeout sweeper that auto-resigns overdue turns honouring each
player's daily away window. Like Stages 1-2 it is a service/store layer with no
HTTP; the gateway surface lands in Stage 6.

Engine: additive decoded domain API (Direction, SubmitPlay/SubmitExchange/
EvaluatePlay/HintView/Hand, MoveRecord.{Dir,MainRow,MainCol}, Registry.Lookup,
ParseVariant) so internal/game never imports scrabble-solver; and a Resign fix
so the resigner keeps their score yet never wins (the other player wins a
two-player game). Timeout reuses Resign.

Persistence: migration 00002 adds games, game_players, game_moves, complaints,
account_stats and extends accounts with away_start/away_end/hint_balance; go-jet
regenerated. account gained SpendHint. Config adds BACKEND_DICT_DIR (required),
BACKEND_DICT_VERSION, BACKEND_GAME_TIMEOUT_SWEEP_INTERVAL, BACKEND_GAME_CACHE_TTL;
main loads the registry at boot (hard dependency) and starts the sweeper.

Tests: engine resign + decoded-API tests; game unit tests (GCG, away-window
boundaries, hint budget, cache, keyed mutex, payload); inttest integration
(lifecycle, replay equivalence, timeout sweep with away grace, resign stats,
hint policy, word-check/complaint, per-game-lock). Docs (PLAN, ARCHITECTURE,
FUNCTIONAL +_ru, TESTING, README) updated.

backend/README.md

@@ -16,14 +16,25 @@ Stage 2 adds `internal/engine`, the in-process bridge to the `scrabble-solver`
 library: a versioned dictionary registry, a deterministic tile bag, and a pure
 rules `Game` (legal plays, passes, exchanges, resignations and end-condition
 detection) that emits dictionary-independent move records. It is a library only;
-the game domain wires it into the server in Stage 3.
+the game domain wires it into the process in Stage 3.
+
+Stage 3 adds `internal/game`, the game domain over the engine. Active games are
+event-sourced: a `games` row plus an append-only decoded move journal, with the
+live `engine.Game` kept warm in a cache and rebuilt by replay on a miss. It
+provides create, the play/pass/exchange/resign transitions, an unlimited
+score/legality preview, the hint (per-game allowance plus a profile wallet), the
+word-check tool with complaint capture, per-player game state, history and GCG
+export, per-account statistics on finish, and a background turn-timeout sweeper
+that auto-resigns overdue turns (honouring each player's daily away window). Like
+Stages 1–2 it is a service/store layer; the HTTP surface lands with the
+`gateway` (Stage 6).
 
 ## Package layout
 
 ```
-cmd/backend/         # process entrypoint: telemetry -> db+migrate -> cache -> server
+cmd/backend/         # entrypoint: telemetry -> db+migrate -> registry -> cache -> game+sweeper -> server
 cmd/jetgen/          # dev tool: regenerate go-jet code from a throwaway container
-internal/config/     # env configuration (composes postgres + telemetry config)
+internal/config/     # env configuration (composes postgres + telemetry + game config)
 internal/telemetry/  # OpenTelemetry providers + per-request timing middleware
 internal/postgres/   # pgx-over-database/sql pool (otelsql), goose migrations
   migrations/        #   embedded *.sql (goose), schema `backend`
@@ -32,6 +43,7 @@ internal/account/    # durable accounts + platform/email identities (store)
 internal/session/    # opaque tokens, sessions store, write-through cache, service
 internal/server/     # gin engine, route groups, X-User-ID middleware, probes
 internal/engine/     # in-process scrabble-solver bridge: registry, bag, Game, replay
+internal/game/       # game domain: lifecycle, journal+cache, hint, word-check, GCG, sweeper
 ```
 
 ## Configuration (environment)
@@ -48,18 +60,26 @@ internal/engine/     # in-process scrabble-solver bridge: registry, bag, Game, r
 | `BACKEND_SERVICE_NAME` | `scrabble-backend` | OpenTelemetry `service.name`. |
 | `BACKEND_OTEL_TRACES_EXPORTER` | `none` | `none` or `stdout` (OTLP arrives later). |
 | `BACKEND_OTEL_METRICS_EXPORTER` | `none` | `none` or `stdout`. |
+| `BACKEND_DICT_DIR` | — | **Required.** Directory of committed `.dawg` dictionaries. |
+| `BACKEND_DICT_VERSION` | `v1` | Dictionary version new games pin. |
+| `BACKEND_GAME_TIMEOUT_SWEEP_INTERVAL` | `1m` | How often the turn-timeout sweeper runs. |
+| `BACKEND_GAME_CACHE_TTL` | `24h` | Idle window before a live game is evicted from cache. |
 
 ## Run
 
 ```sh
 docker run -d --name scrabble-pg -e POSTGRES_PASSWORD=dev -p 5432:5432 postgres:17-alpine
 BACKEND_POSTGRES_DSN='postgres://postgres:dev@localhost:5432/postgres?search_path=backend&sslmode=disable' \
+  BACKEND_DICT_DIR=../../scrabble-solver/dawg \
   go run ./cmd/backend
 ```
 
-On boot the backend opens the pool, creates the `backend` schema if needed, and
-applies the embedded migrations. `GET /healthz` reports liveness; `GET /readyz`
-reports 200 only when the database answers and the session cache is warmed.
+On boot the backend opens the pool, creates the `backend` schema if needed,
+applies the embedded migrations, loads the dictionaries into the engine registry
+(a hard dependency — a missing dictionary aborts the boot), warms the session
+cache and starts the game turn-timeout sweeper. `GET /healthz` reports liveness;
+`GET /readyz` reports 200 only when the database answers and the session cache is
+warmed.
 
 ## Migrations & generated code
 
@@ -82,10 +102,10 @@ dependency. CI clones the public solver repository into `../scrabble-solver`
 before building (see `.gitea/workflows/`); locally, check it out next to this
 repository. Committed dictionaries (`en_sowpods.dawg`, `ru_scrabble.dawg`,
 `ru_erudit.dawg`) live in the solver's `dawg/` directory; the engine loads them
-by `(variant, dict_version)` from a directory path. A configurable
-`BACKEND_DICT_DIR` is wired when the first consumer needs it (Stage 3); the
-future versioned-artifact direction is recorded in [`../PLAN.md`](../PLAN.md)
-TODO-2.
+by `(variant, dict_version)` from a directory path. Since Stage 3 the backend
+loads them at startup from the **required** `BACKEND_DICT_DIR` (a missing
+dictionary aborts the boot); the future versioned-artifact direction is recorded
+in [`../PLAN.md`](../PLAN.md) TODO-2.
 
 ## Tests