feat(stats): show the best move word per game variant

Replace the single "best move" number on the statistics screen with a
full-width per-variant breakdown: the highest-scoring play in each variant
the player has played, drawn as game tiles (a wildcard shows its letter but
no value), with the words and scores right-aligned to shared edges.

- backend: new account_best_move table (PK account_id+variant) keeping the
  main word as JSON tiles {letter,value,blank}; captured at game finish in
  buildStats (blank flags taken from every placed blank — equivalent to the
  final board), upserted in the finish transaction and replaced only by a
  strictly higher-scoring play. Guest/honest-AI games still record nothing.
  GetStats + statsDTO expose best_moves.
- wire: StatsView gains best_moves:[BestMoveView{variant,score,word:[BestMoveTile]}]
  (trailing, backward-compatible); gateway encodeStats + UI codec updated.
- ui: new WordTiles component (board's tile look, fixed px size); Stats.svelte
  drops the maxWord card and adds the full-width best-move card (catalogue
  order, empty variants omitted).
- docs: ARCHITECTURE §9 + schema, FUNCTIONAL (+ru), UI_DESIGN.

Tests: mainWordTiles unit + buildStats end-to-end (inttest) + gateway and UI
codec round-trips (incl. a blank tile) + e2e.

backend/internal/game/store.go

@@ -3,6 +3,7 @@ package game
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"hash/fnv"
@@ -12,6 +13,7 @@ import (
 	"github.com/go-jet/jet/v2/qrm"
 	"github.com/google/uuid"
 
+	"scrabble/backend/internal/account"
 	"scrabble/backend/internal/engine"
 	"scrabble/backend/internal/postgres/jet/backend/model"
 	"scrabble/backend/internal/postgres/jet/backend/table"
@@ -53,13 +55,20 @@ type gameInsert struct {
 }
 
 // statDelta is one account's contribution to its statistics on a game finish.
+// bestVariant/bestScore/bestTiles describe the game's best play for this account when
+// it scored (bestVariant empty otherwise): the variant label, the play's total score and
+// its main word as rendering tiles. They feed the per-variant account_best_move upsert,
+// which keeps only the account's highest-scoring play per variant.
 type statDelta struct {
-	accountID  uuid.UUID
-	wins       int
-	losses     int
-	draws      int
-	gamePoints int
-	wordPoints int
+	accountID   uuid.UUID
+	wins        int
+	losses      int
+	draws       int
+	gamePoints  int
+	wordPoints  int
+	bestVariant string
+	bestScore   int
+	bestTiles   []account.BestMoveTile
 }
 
 // commit is everything a single committed transition persists: the journal row,
@@ -633,6 +642,9 @@ func (s *Store) CommitMove(ctx context.Context, c commit) error {
 				if err := upsertStats(ctx, tx, d, c.now); err != nil {
 					return err
 				}
+				if err := upsertBestMove(ctx, tx, d, c.now); err != nil {
+					return err
+				}
 			}
 		}
 		return nil
@@ -662,6 +674,9 @@ func (s *Store) VoidGame(ctx context.Context, v voidCommit) error {
 			if err := upsertStats(ctx, tx, d, v.now); err != nil {
 				return err
 			}
+			if err := upsertBestMove(ctx, tx, d, v.now); err != nil {
+				return err
+			}
 		}
 		return nil
 	})
@@ -728,6 +743,37 @@ func upsertStats(ctx context.Context, tx *sql.Tx, d statDelta, now time.Time) er
 	return nil
 }
 
+// upsertBestMove records the account's best play for a variant, keeping only the
+// highest-scoring one: a first play inserts, a later one replaces it only when it scored
+// strictly higher (the conditional DO UPDATE makes the upsert atomic under concurrent
+// finishes without a separate lock). It is a no-op when the finish carries no scoring play
+// for the account (a draw with no plays, or an exchange/pass-only game).
+func upsertBestMove(ctx context.Context, tx *sql.Tx, d statDelta, now time.Time) error {
+	if d.bestVariant == "" || len(d.bestTiles) == 0 {
+		return nil
+	}
+	tiles, err := json.Marshal(d.bestTiles)
+	if err != nil {
+		return fmt.Errorf("marshal best move %s/%s: %w", d.accountID, d.bestVariant, err)
+	}
+	stmt := table.AccountBestMove.
+		INSERT(
+			table.AccountBestMove.AccountID, table.AccountBestMove.Variant,
+			table.AccountBestMove.Score, table.AccountBestMove.Tiles, table.AccountBestMove.UpdatedAt,
+		).
+		VALUES(d.accountID, d.bestVariant, d.bestScore, string(tiles), postgres.TimestampzT(now)).
+		ON_CONFLICT(table.AccountBestMove.AccountID, table.AccountBestMove.Variant).
+		DO_UPDATE(postgres.SET(
+			table.AccountBestMove.Score.SET(table.AccountBestMove.EXCLUDED.Score),
+			table.AccountBestMove.Tiles.SET(table.AccountBestMove.EXCLUDED.Tiles),
+			table.AccountBestMove.UpdatedAt.SET(table.AccountBestMove.EXCLUDED.UpdatedAt),
+		).WHERE(table.AccountBestMove.EXCLUDED.Score.GT(table.AccountBestMove.Score)))
+	if _, err := stmt.ExecContext(ctx, tx); err != nil {
+		return fmt.Errorf("upsert best move %s/%s: %w", d.accountID, d.bestVariant, err)
+	}
+	return nil
+}
+
 // SpendHintAllowance increments a seat's per-game hint counter by one.
 func (s *Store) SpendHintAllowance(ctx context.Context, gameID uuid.UUID, seat int) error {
 	stmt := table.GamePlayers.