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/internal/engine/registry.go

@@ -135,6 +135,29 @@ func (r *Registry) Versions(v Variant) []string {
 	return versions
 }
 
+// Lookup reports whether word is present in the (variant, version) dictionary,
+// backing the unlimited word-check tool. It returns ErrUnknownVariant or
+// ErrUnknownVersion when that dictionary is not resident, and an error when word
+// contains a character outside the variant's alphabet. The word is matched as
+// given; callers normalise case to the variant's alphabet first.
+func (r *Registry) Lookup(v Variant, version, word string) (bool, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	versions, ok := r.entries[v]
+	if !ok {
+		return false, fmt.Errorf("%w: %s", ErrUnknownVariant, v)
+	}
+	e, ok := versions[version]
+	if !ok {
+		return false, fmt.Errorf("%w: %s/%s", ErrUnknownVersion, v, version)
+	}
+	idx, err := e.finder.IndexOf(word)
+	if err != nil {
+		return false, fmt.Errorf("engine: lookup %q in %s/%s: %w", word, v, version, err)
+	}
+	return idx >= 0, nil
+}
+
 // Close releases every resident dictionary and empties the registry. It is safe
 // to call more than once; the first close error is returned after all finders
 // have been closed.