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/connector/server.go

@@ -4,15 +4,14 @@
 // methods address a recipient by the identity external_id, so a future platform
 // connector can implement the same service.
 //
-// The connector hosts one bot per configured service language (en/ru); the same
-// Telegram user id spans them all. ValidateInitData tries each bot's token in turn
-// and reports which bot validated (its service language); the push and admin
-// methods route to the bot the request selects by language.
+// The connector hosts a single bot. ValidateInitData/ValidateLoginWidget verify
+// launch data against its token; Notify renders the message in the recipient's
+// interface language (the single bot needs no routing); the admin methods deliver
+// through that bot.
 package connector
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strconv"
 
@@ -34,103 +33,70 @@ type Sender interface {
 	SendText(ctx context.Context, chatID int64, text string) error
 }
 
-// BotRuntime is one configured language-tagged bot: its sender, game channel id,
-// and the two HMAC validators bound to its token.
+// BotRuntime is the configured bot: its sender, game channel id, and the two HMAC
+// validators bound to its token.
 type BotRuntime struct {
-	// Language is the bot's service language (en/ru).
-	Language string
-	// Sender delivers messages through this bot.
+	// Sender delivers messages through the bot.
 	Sender Sender
-	// ChannelID is this bot's game channel (0 disables channel posts).
+	// ChannelID is the bot's game channel (0 disables channel posts).
 	ChannelID int64
-	// InitValidator verifies Mini App initData signed by this bot's token.
+	// InitValidator verifies Mini App initData signed by the bot's token.
 	InitValidator initdata.Validator
-	// WidgetValidator verifies Login Widget data signed by this bot's token.
+	// WidgetValidator verifies Login Widget data signed by the bot's token.
 	WidgetValidator loginwidget.Validator
 }
 
-// Server implements telegramv1.TelegramServer over one or more language-tagged bots.
+// Server implements telegramv1.TelegramServer over the single configured bot.
 type Server struct {
 	telegramv1.UnimplementedTelegramServer
-	bots  map[string]BotRuntime // keyed by service language
-	order []string              // stable iteration order for validation
-	log   *zap.Logger
+	bot BotRuntime
+	log *zap.Logger
 }
 
-// NewServer builds the gRPC service from the configured bots (at least one).
-func NewServer(bots []BotRuntime, log *zap.Logger) *Server {
+// NewServer builds the gRPC service from the configured bot.
+func NewServer(bot BotRuntime, log *zap.Logger) *Server {
 	if log == nil {
 		log = zap.NewNop()
 	}
-	m := make(map[string]BotRuntime, len(bots))
-	order := make([]string, 0, len(bots))
-	for _, b := range bots {
-		m[b.Language] = b
-		order = append(order, b.Language)
-	}
-	return &Server{bots: m, order: order, log: log}
+	return &Server{bot: bot, log: log}
 }
 
-// ValidateInitData verifies Mini App launch data against each bot's token in turn
-// and returns the user identity plus the validating bot's service language (which
-// routes the user's later push) and its set of offered game languages.
+// ValidateInitData verifies Mini App launch data against the bot's token and returns
+// the user identity.
 func (s *Server) ValidateInitData(ctx context.Context, req *telegramv1.ValidateInitDataRequest) (*telegramv1.ValidateInitDataResponse, error) {
-	var lastErr error
-	for _, lang := range s.order {
-		u, err := s.bots[lang].InitValidator.Validate(req.GetInitData())
-		if err != nil {
-			lastErr = err
-			continue
-		}
-		return &telegramv1.ValidateInitDataResponse{
-			ExternalId:         u.ExternalID,
-			Username:           u.Username,
-			FirstName:          u.FirstName,
-			LanguageCode:       u.LanguageCode,
-			ServiceLanguage:    lang,
-			SupportedLanguages: []string{lang},
-		}, nil
+	u, err := s.bot.InitValidator.Validate(req.GetInitData())
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if lastErr == nil {
-		lastErr = errors.New("no bot configured")
-	}
-	return nil, status.Error(codes.InvalidArgument, lastErr.Error())
+	return &telegramv1.ValidateInitDataResponse{
+		ExternalId:   u.ExternalID,
+		Username:     u.Username,
+		FirstName:    u.FirstName,
+		LanguageCode: u.LanguageCode,
+	}, nil
 }
 
-// ValidateLoginWidget verifies Login Widget authorization data against each bot's
-// token in turn and returns the user identity, for attaching a Telegram identity to
-// an existing account.
+// ValidateLoginWidget verifies Login Widget authorization data against the bot's
+// token and returns the user identity, for attaching a Telegram identity to an
+// existing account.
 func (s *Server) ValidateLoginWidget(ctx context.Context, req *telegramv1.ValidateLoginWidgetRequest) (*telegramv1.ValidateLoginWidgetResponse, error) {
-	var lastErr error
-	for _, lang := range s.order {
-		u, err := s.bots[lang].WidgetValidator.Validate(req.GetData())
-		if err != nil {
-			lastErr = err
-			continue
-		}
-		return &telegramv1.ValidateLoginWidgetResponse{
-			ExternalId: u.ExternalID,
-			Username:   u.Username,
-			FirstName:  u.FirstName,
-		}, nil
+	u, err := s.bot.WidgetValidator.Validate(req.GetData())
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if lastErr == nil {
-		lastErr = errors.New("no bot configured")
-	}
-	return nil, status.Error(codes.InvalidArgument, lastErr.Error())
+	return &telegramv1.ValidateLoginWidgetResponse{
+		ExternalId: u.ExternalID,
+		Username:   u.Username,
+		FirstName:  u.FirstName,
+	}, nil
 }
 
-// Notify renders and delivers an out-of-app notification through the bot selected by
-// the recipient's service language. It reports delivered=false (without an error)
-// when no bot serves that language, the kind is not pushed out-of-app, or the bot
-// could not deliver (e.g. the user never started it), so the gateway treats a
+// Notify renders and delivers an out-of-app notification through the bot. The message
+// is rendered in the recipient's interface language (req language). It reports
+// delivered=false (without an error) when the kind is not pushed out-of-app or the
+// bot could not deliver (e.g. the user never started it), so the gateway treats a
 // fallback miss as best-effort.
 func (s *Server) Notify(ctx context.Context, req *telegramv1.NotifyRequest) (*telegramv1.NotifyResponse, error) {
-	bot, ok := s.bots[req.GetLanguage()]
-	if !ok {
-		s.log.Warn("notify: no bot for language", zap.String("language", req.GetLanguage()), zap.String("kind", req.GetKind()))
-		return &telegramv1.NotifyResponse{Delivered: false}, nil
-	}
 	msg, ok := render.Render(req.GetKind(), req.GetPayload(), req.GetLanguage())
 	if !ok {
 		return &telegramv1.NotifyResponse{Delivered: false}, nil
@@ -139,58 +105,38 @@ func (s *Server) Notify(ctx context.Context, req *telegramv1.NotifyRequest) (*te
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if err := bot.Sender.Notify(ctx, chat, msg.Text, msg.ButtonText, msg.StartParam); err != nil {
+	if err := s.bot.Sender.Notify(ctx, chat, msg.Text, msg.ButtonText, msg.StartParam); err != nil {
 		s.log.Warn("notify delivery failed", zap.String("kind", req.GetKind()), zap.Error(err))
 		return &telegramv1.NotifyResponse{Delivered: false}, nil
 	}
 	return &telegramv1.NotifyResponse{Delivered: true}, nil
 }
 
-// SendToUser sends an arbitrary admin message to one user through the bot selected
-// by language (an operator choice in the admin console).
+// SendToUser sends an arbitrary admin message to one user through the bot.
 func (s *Server) SendToUser(ctx context.Context, req *telegramv1.SendToUserRequest) (*telegramv1.SendResponse, error) {
-	bot, err := s.botFor(req.GetLanguage())
-	if err != nil {
-		return nil, err
-	}
 	chat, err := parseChatID(req.GetExternalId())
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
-	if err := bot.Sender.SendText(ctx, chat, req.GetText()); err != nil {
+	if err := s.bot.Sender.SendText(ctx, chat, req.GetText()); err != nil {
 		s.log.Warn("send to user failed", zap.Error(err))
 		return &telegramv1.SendResponse{Delivered: false}, nil
 	}
 	return &telegramv1.SendResponse{Delivered: true}, nil
 }
 
-// SendToGameChannel posts an arbitrary admin message to the game channel of the bot
-// selected by language (an operator choice in the admin console).
+// SendToGameChannel posts an arbitrary admin message to the bot's game channel.
 func (s *Server) SendToGameChannel(ctx context.Context, req *telegramv1.SendToGameChannelRequest) (*telegramv1.SendResponse, error) {
-	bot, err := s.botFor(req.GetLanguage())
-	if err != nil {
-		return nil, err
+	if s.bot.ChannelID == 0 {
+		return nil, status.Error(codes.FailedPrecondition, "game channel is not configured")
 	}
-	if bot.ChannelID == 0 {
-		return nil, status.Error(codes.FailedPrecondition, fmt.Sprintf("game channel is not configured for language %q", req.GetLanguage()))
-	}
-	if err := bot.Sender.SendText(ctx, bot.ChannelID, req.GetText()); err != nil {
+	if err := s.bot.Sender.SendText(ctx, s.bot.ChannelID, req.GetText()); err != nil {
 		s.log.Warn("send to channel failed", zap.Error(err))
 		return &telegramv1.SendResponse{Delivered: false}, nil
 	}
 	return &telegramv1.SendResponse{Delivered: true}, nil
 }
 
-// botFor returns the bot tagged with language, or a FailedPrecondition error when no
-// bot serves it (admin broadcasts choose the language explicitly).
-func (s *Server) botFor(language string) (BotRuntime, error) {
-	bot, ok := s.bots[language]
-	if !ok {
-		return BotRuntime{}, status.Error(codes.FailedPrecondition, fmt.Sprintf("no bot configured for language %q", language))
-	}
-	return bot, nil
-}
-
 // parseChatID converts a Telegram identity external_id into a numeric chat id.
 func parseChatID(externalID string) (int64, error) {
 	id, err := strconv.ParseInt(externalID, 10, 64)