feat(telegram,game): single bot + per-user variant preferences

Collapse the two per-language Telegram bots into one unified bot and
replace language-based variant gating with explicit per-user variant
preferences.

- Telegram: one bot; drop service_language and the supported_languages
  set everywhere (DB, account, auth, FlatBuffers Session wire, gateway,
  connector proto). The single bot renders chat and out-of-app push in
  the recipient's preferred_language; remove the game-language push
  routing override (notify Intent.Language / push Event.language).
- Preferences: new accounts.variant_preferences (text[], DB default
  {erudit_ru}, CHECK non-empty + subset of the three variants). Gates
  the New Game picker, vs-AI and the friend invitation the player
  creates, enforced server-side (HTTP 400 otherwise); an invited friend
  may still accept any variant. Edited on the Settings screen; variants
  are Erudit-first everywhere.
- Admin: drop the per-bot language selectors (broadcast / send-to-user)
  and the feedback channel_lang column/field.
- Env/CI: collapse TELEGRAM_BOT_TOKEN_{EN,RU}, TELEGRAM_GAME_CHANNEL_ID_{EN,RU},
  VITE_TELEGRAM_LINK{,_EN,_RU} and VITE_TELEGRAM_GAME_CHANNEL_NAME_{EN,RU}
  to single unsuffixed names; drop GATEWAY_DEFAULT_SUPPORTED_LANGUAGES.
- Docs updated (ARCHITECTURE, FUNCTIONAL + _ru, platform/telegram, gateway,
  backend, ui, UI_DESIGN, PRERELEASE).

The migration squash is deferred to a follow-up PR.

platform/telegram/internal/config/config.go

@@ -10,40 +10,26 @@ import (
 	pkgtel "scrabble/pkg/telemetry"
 )
 
-// Languages is the set of service languages a bot may be tagged with. Each is a
-// separate bot (own token + game channel) serving that audience; the same Telegram
-// user id spans them all (ARCHITECTURE.md §12).
-var Languages = []string{"en", "ru"}
-
-// BotConfig is one language-tagged bot's settings.
-type BotConfig struct {
-	// Token is the Telegram Bot API token (TELEGRAM_BOT_TOKEN_<LANG>). It both
-	// authenticates the Bot API client and is the HMAC secret for Mini App initData
-	// validation against this bot.
-	Token string
-	// GameChannelID is the chat id of this bot's game channel for SendToGameChannel
-	// (TELEGRAM_GAME_CHANNEL_ID_<LANG>, optional; 0 disables channel posts).
-	GameChannelID int64
-}
-
 // Config is the Telegram connector's runtime configuration, read from the
-// environment. The bot tokens live only in this process (ARCHITECTURE.md §12).
+// environment. The bot token lives only in this process (ARCHITECTURE.md §12).
 type Config struct {
-	// Bots maps a service language (one of Languages) to that language's bot
-	// settings. A language is present when its TELEGRAM_BOT_TOKEN_<LANG> is set; at
-	// least one bot is required.
-	Bots map[string]BotConfig
+	// Token is the Telegram Bot API token (TELEGRAM_BOT_TOKEN, required). It both
+	// authenticates the Bot API client and is the HMAC secret for Mini App initData
+	// and Login Widget validation.
+	Token string
+	// GameChannelID is the chat id of the bot's game channel for SendToGameChannel
+	// (TELEGRAM_GAME_CHANNEL_ID, optional; 0 disables channel posts).
+	GameChannelID int64
 	// GRPCAddr is the listen address of the connector gRPC server that gateway and
 	// backend call (TELEGRAM_GRPC_ADDR, default :9091).
 	GRPCAddr string
 	// MiniAppURL is the HTTPS origin of the Mini App registered with BotFather; it
 	// is the base of every launch button, to which a deep-link adds a startapp
-	// query parameter (TELEGRAM_MINIAPP_URL, required). It is shared by all bots
-	// (one gateway origin); initData is signed per bot token.
+	// query parameter (TELEGRAM_MINIAPP_URL, required).
 	MiniAppURL string
 	// APIBaseURL overrides the Bot API host (TELEGRAM_API_BASE_URL, optional;
 	// default https://api.telegram.org) — used for a local mock or a self-hosted
-	// Bot API server. Shared by all bots.
+	// Bot API server.
 	APIBaseURL string
 	// TestEnv routes the Bot API client to Telegram's test environment
 	// (.../bot<token>/test/METHOD) (TELEGRAM_TEST_ENV=true, default false).
@@ -58,36 +44,27 @@ type Config struct {
 // and validating the required fields.
 func Load() (Config, error) {
 	cfg := Config{
-		Bots:       map[string]BotConfig{},
+		Token:      os.Getenv("TELEGRAM_BOT_TOKEN"),
 		GRPCAddr:   envOr("TELEGRAM_GRPC_ADDR", ":9091"),
 		MiniAppURL: os.Getenv("TELEGRAM_MINIAPP_URL"),
 		APIBaseURL: os.Getenv("TELEGRAM_API_BASE_URL"),
 		TestEnv:    os.Getenv("TELEGRAM_TEST_ENV") == "true",
 		LogLevel:   envOr("TELEGRAM_LOG_LEVEL", "info"),
 	}
-	for _, lang := range Languages {
-		suffix := strings.ToUpper(lang)
-		token := os.Getenv("TELEGRAM_BOT_TOKEN_" + suffix)
-		if token == "" {
-			continue
+	if v := strings.TrimSpace(os.Getenv("TELEGRAM_GAME_CHANNEL_ID")); v != "" {
+		id, err := strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			return Config{}, fmt.Errorf("config: TELEGRAM_GAME_CHANNEL_ID %q: %w", v, err)
 		}
-		bot := BotConfig{Token: token}
-		if v := strings.TrimSpace(os.Getenv("TELEGRAM_GAME_CHANNEL_ID_" + suffix)); v != "" {
-			id, err := strconv.ParseInt(v, 10, 64)
-			if err != nil {
-				return Config{}, fmt.Errorf("config: TELEGRAM_GAME_CHANNEL_ID_%s %q: %w", suffix, v, err)
-			}
-			bot.GameChannelID = id
-		}
-		cfg.Bots[lang] = bot
+		cfg.GameChannelID = id
 	}
 	tel := pkgtel.DefaultConfig("scrabble-telegram")
 	tel.ServiceName = envOr("TELEGRAM_SERVICE_NAME", tel.ServiceName)
 	tel.TracesExporter = envOr("TELEGRAM_OTEL_TRACES_EXPORTER", tel.TracesExporter)
 	tel.MetricsExporter = envOr("TELEGRAM_OTEL_METRICS_EXPORTER", tel.MetricsExporter)
 	cfg.Telemetry = tel
-	if len(cfg.Bots) == 0 {
-		return Config{}, fmt.Errorf("config: at least one TELEGRAM_BOT_TOKEN_<LANG> (LANG in %v) is required", Languages)
+	if cfg.Token == "" {
+		return Config{}, fmt.Errorf("config: TELEGRAM_BOT_TOKEN is required")
 	}
 	if cfg.MiniAppURL == "" {
 		return Config{}, fmt.Errorf("config: TELEGRAM_MINIAPP_URL is required")

platform/telegram/internal/config/config_test.go

@@ -6,33 +6,38 @@ import (
 	pkgtel "scrabble/pkg/telemetry"
 )
 
-// setRequired sets the required connector variables (one bot + the Mini App URL)
-// so Load reaches the telemetry checks.
+// setRequired sets the required connector variables (the bot token + the Mini App
+// URL) so Load reaches the telemetry checks.
 func setRequired(t *testing.T) {
 	t.Helper()
-	t.Setenv("TELEGRAM_BOT_TOKEN_EN", "test-token")
+	t.Setenv("TELEGRAM_BOT_TOKEN", "test-token")
 	t.Setenv("TELEGRAM_MINIAPP_URL", "https://example.org/app")
 }
 
-// TestLoadBots verifies the per-language bot parsing: a present token enables a
-// language, its channel id is optional, and the result is keyed by language.
-func TestLoadBots(t *testing.T) {
+// TestLoadBot verifies the bot parsing: the token is read and the game channel id is
+// parsed when present.
+func TestLoadBot(t *testing.T) {
 	t.Setenv("TELEGRAM_MINIAPP_URL", "https://example.org/app")
-	t.Setenv("TELEGRAM_BOT_TOKEN_EN", "en-token")
-	t.Setenv("TELEGRAM_GAME_CHANNEL_ID_EN", "-100111")
-	t.Setenv("TELEGRAM_BOT_TOKEN_RU", "ru-token")
+	t.Setenv("TELEGRAM_BOT_TOKEN", "bot-token")
+	t.Setenv("TELEGRAM_GAME_CHANNEL_ID", "-100111")
 	c, err := Load()
 	if err != nil {
 		t.Fatalf("Load: %v", err)
 	}
-	if len(c.Bots) != 2 {
-		t.Fatalf("Bots = %d, want 2", len(c.Bots))
+	if c.Token != "bot-token" || c.GameChannelID != -100111 {
+		t.Errorf("config = token %q / channel %d, want bot-token / -100111", c.Token, c.GameChannelID)
 	}
-	if c.Bots["en"].Token != "en-token" || c.Bots["en"].GameChannelID != -100111 {
-		t.Errorf("en bot = %+v", c.Bots["en"])
+}
+
+// TestLoadOptionalChannel verifies the game channel id defaults to 0 when unset.
+func TestLoadOptionalChannel(t *testing.T) {
+	setRequired(t)
+	c, err := Load()
+	if err != nil {
+		t.Fatalf("Load: %v", err)
 	}
-	if c.Bots["ru"].Token != "ru-token" || c.Bots["ru"].GameChannelID != 0 {
-		t.Errorf("ru bot = %+v, want token ru-token / channel 0", c.Bots["ru"])
+	if c.GameChannelID != 0 {
+		t.Errorf("GameChannelID = %d, want 0", c.GameChannelID)
 	}
 }