feat(lobby): cap simultaneous quick games at 10

Limit a player to 10 active quick games (auto-match + AI); friend games created
by invitation are not counted. At the cap the backend refuses both new-game
entry points — quick enqueue and invitation creation — with 409
game_limit_reached, while accepting an incoming invitation stays allowed, so
friend games are capped from the other end. The lobby disables "New Game" and
shows a low-emphasis notice, driven by a new at_game_limit flag on games.list
(no per-event payload: a turn change does not move the count, and the lobby
already re-fetches games.list on entry and every game event).

- game.MaxActiveQuickGames + Store/Service.CountActiveQuickGames (active/open
  seats, no game_invitations row; hidden games still count -> dedicated count)
- Server.ensureUnderGameLimit gating handleEnqueue + handleCreateInvitation;
  game.ErrGameLimitReached -> 409 game_limit_reached
- FB GameList.at_game_limit (regenerated Go + TS) through the gateway transcode
  and UI codec; gameListDTO + lobbycache snapshot + Lobby.svelte + i18n
- tests: integration count rule + HTTP gate + accept bypass; server error map;
  gateway transcode round-trip; UI codec + lobbycache unit; e2e gamelimit
- docs: PRERELEASE (GL), FUNCTIONAL(+ru), ARCHITECTURE 8, UI_DESIGN, backend README

backend/internal/game/service.go

@@ -1178,6 +1178,14 @@ func (svc *Service) ListForAccount(ctx context.Context, accountID uuid.UUID) ([]
 	return svc.store.ListGamesForAccount(ctx, accountID)
 }
 
+// CountActiveQuickGames reports how many in-progress quick games the account holds —
+// the count the simultaneous-game limit (MaxActiveQuickGames) is checked against. It
+// counts active and still-open quick games (including honest-AI ones) and excludes
+// friend games created by invitation and finished games. See Store.CountActiveQuickGames.
+func (svc *Service) CountActiveQuickGames(ctx context.Context, accountID uuid.UUID) (int, error) {
+	return svc.store.CountActiveQuickGames(ctx, accountID)
+}
+
 // HideGame hides a finished game from accountID's own lobby (it stays visible to the other
 // players); it is irreversible by design. Only a player of a finished game may hide it
 // (ErrNotAPlayer / ErrGameActive otherwise); hiding an already-hidden game is a no-op.

backend/internal/game/store.go

@@ -450,6 +450,28 @@ func (s *Store) ListGamesForAccount(ctx context.Context, accountID uuid.UUID) ([
 	return out, nil
 }
 
+// CountActiveQuickGames counts the account's in-progress quick games — the ones the
+// simultaneous-game limit (MaxActiveQuickGames) is checked against. It includes both
+// active and still-open (awaiting-opponent) games, the honest-AI ones among them, and
+// excludes friend games (those linked to a game_invitations row) and finished games.
+// A hidden game still occupies a slot, so this is a dedicated count rather than a
+// filter over ListGamesForAccount (which drops hidden games). Joining on the account's
+// own seat counts each game once (an open game's empty opponent seat has no account).
+func (s *Store) CountActiveQuickGames(ctx context.Context, accountID uuid.UUID) (int, error) {
+	// The status literals are game.StatusActive / game.StatusOpen, matching the
+	// games.status CHECK in the baseline migration.
+	const q = `
+SELECT COUNT(*) FROM backend.games g
+JOIN backend.game_players gp ON gp.game_id = g.game_id
+LEFT JOIN backend.game_invitations gi ON gi.game_id = g.game_id
+WHERE gp.account_id = $1 AND g.status IN ('active', 'open') AND gi.game_id IS NULL`
+	var n int
+	if err := s.db.QueryRowContext(ctx, q, accountID).Scan(&n); err != nil {
+		return 0, fmt.Errorf("game: count active quick games: %w", err)
+	}
+	return n, nil
+}
+
 // HideGame hides a game from the account's own lobby list (idempotent). The caller validates the
 // game is finished and the account is a player.
 func (s *Store) HideGame(ctx context.Context, accountID, gameID uuid.UUID) error {

backend/internal/game/types.go

@@ -65,6 +65,9 @@ var (
 	ErrNoHintsLeft = errors.New("game: no hints remaining")
 	// ErrNoHintAvailable is returned when the player has no legal play to reveal.
 	ErrNoHintAvailable = errors.New("game: no legal move to suggest")
+	// ErrGameLimitReached is returned when an account already holds MaxActiveQuickGames
+	// simultaneous quick games and tries to create another game (quick or by invitation).
+	ErrGameLimitReached = errors.New("game: simultaneous game limit reached")
 )
 
 // AllowedTurnTimeouts is the set of per-game move clocks a game may be created
@@ -87,6 +90,15 @@ const DefaultTurnTimeout = 24 * time.Hour
 // one of AllowedTurnTimeouts (never offered in the creation UI).
 const AIInactivityTimeout = 7 * 24 * time.Hour
 
+// MaxActiveQuickGames is the cap on a player's simultaneous quick games (human
+// auto-match and honest-AI), counting both in-progress (StatusActive) and
+// still-open, awaiting-opponent (StatusOpen) games. Friend games created by
+// invitation are not counted. At the cap the backend refuses to create a new game
+// of any kind — quick or by invitation — and the lobby disables "New Game";
+// accepting an incoming invitation is always allowed. See
+// Store.CountActiveQuickGames.
+const MaxActiveQuickGames = 10
+
 // aiPlayerName labels the robot seat in an honest-AI game's GCG export, so a downloaded
 // game file shows a clean "AI" rather than the robot's human-like pool name (the in-app
 // UI shows 🤖 from the game's vs_ai flag).