Stage 9: Telegram integration (connector side-service, Mini App, out-of-app push)

New platform/telegram connector (own container, bot token only there):
- go-telegram/bot long-poll loop: /start deep-links + Mini App launch button.
- gRPC API pkg/proto/telegram/v1 (Telegram service): ValidateInitData, Notify
  (renders a localized message + deep-link button), SendToUser/SendToGameChannel
  (admin, wired in Stage 10). Generic methods are platform-agnostic (external_id).
- Bot API base override for Telegram's test environment; Dockerfile + compose
  (VPN sidecar, no public ingress); README.

Gateway:
- initData validation relocated from the gateway into the connector; the gateway
  calls ValidateInitData over gRPC (GATEWAY_CONNECTOR_ADDR), drops the bot token,
  and deletes internal/auth.
- Out-of-app push: runPushPump routes events whose recipient has no live in-app
  stream to connector.Notify, gated by /internal/push-target + the in-app-only
  flag (race-free de-dup); HasSubscribers added to the push hub.

Backend:
- Migration 00007 accounts.notifications_in_app_only (default true) + jetgen.
- ProvisionTelegram seeds a new account's language/display name from the launch
  fields; IdentityExternalID reverse lookup; /internal/push-target handler.

UI:
- Telegram Mini App launch: detect initData, apply themeParams, authTelegram,
  route the deep-link start_param (g/i/f); /telegram/ guard redirects outside
  Telegram. Vite relative base + telegram-web-app.js. In-app-only profile toggle;
  share-to-Telegram link for a friend code. Vitest + Playwright coverage.

Wire/docs/CI: fbs Profile/UpdateProfileRequest gain notifications_in_app_only
(Go + TS); go.work uses ./platform/telegram; go-unit.yaml covers it; PLAN,
ARCHITECTURE, FUNCTIONAL (+ru), UI_DESIGN, READMEs updated.

platform/telegram/internal/render/render_test.go

@@ -0,0 +1,115 @@
+package render
+
+import (
+	"testing"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+
+	"scrabble/pkg/fbs/scrabblefb"
+)
+
+const gameID = "7c9e6679-7425-40de-944b-e07fc1f90ae7"
+
+func yourTurnPayload(id string) []byte {
+	b := flatbuffers.NewBuilder(0)
+	gid := b.CreateString(id)
+	scrabblefb.YourTurnEventStart(b)
+	scrabblefb.YourTurnEventAddGameId(b, gid)
+	b.Finish(scrabblefb.YourTurnEventEnd(b))
+	return b.FinishedBytes()
+}
+
+func nudgePayload(id string) []byte {
+	b := flatbuffers.NewBuilder(0)
+	gid := b.CreateString(id)
+	scrabblefb.NudgeEventStart(b)
+	scrabblefb.NudgeEventAddGameId(b, gid)
+	b.Finish(scrabblefb.NudgeEventEnd(b))
+	return b.FinishedBytes()
+}
+
+func matchFoundPayload(id string) []byte {
+	b := flatbuffers.NewBuilder(0)
+	gid := b.CreateString(id)
+	scrabblefb.MatchFoundEventStart(b)
+	scrabblefb.MatchFoundEventAddGameId(b, gid)
+	b.Finish(scrabblefb.MatchFoundEventEnd(b))
+	return b.FinishedBytes()
+}
+
+func notifyPayload(kind string) []byte {
+	b := flatbuffers.NewBuilder(0)
+	k := b.CreateString(kind)
+	scrabblefb.NotificationEventStart(b)
+	scrabblefb.NotificationEventAddKind(b, k)
+	b.Finish(scrabblefb.NotificationEventEnd(b))
+	return b.FinishedBytes()
+}
+
+func TestRenderGameEvents(t *testing.T) {
+	cases := []struct {
+		name, kind string
+		payload    []byte
+	}{
+		{"your_turn", "your_turn", yourTurnPayload(gameID)},
+		{"nudge", "nudge", nudgePayload(gameID)},
+		{"match_found", "match_found", matchFoundPayload(gameID)},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name+" en", func(t *testing.T) {
+			m, ok := Render(tc.kind, tc.payload, "en")
+			if !ok {
+				t.Fatal("expected ok")
+			}
+			if m.StartParam != "g"+gameID {
+				t.Errorf("StartParam = %q, want g%s", m.StartParam, gameID)
+			}
+			if m.ButtonText != "Open game" {
+				t.Errorf("ButtonText = %q, want Open game", m.ButtonText)
+			}
+			if m.Text == "" {
+				t.Error("Text is empty")
+			}
+		})
+		t.Run(tc.name+" ru", func(t *testing.T) {
+			m, ok := Render(tc.kind, tc.payload, "ru")
+			if !ok {
+				t.Fatal("expected ok")
+			}
+			if m.ButtonText != "Открыть игру" {
+				t.Errorf("ButtonText = %q, want Открыть игру", m.ButtonText)
+			}
+		})
+	}
+}
+
+func TestRenderNotify(t *testing.T) {
+	cases := map[string]struct {
+		subKind string
+		wantOK  bool
+	}{
+		"invitation":     {"invitation", true},
+		"friend_request": {"friend_request", true},
+		"friend_added":   {"friend_added", false},
+		"game_started":   {"game_started", false},
+	}
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			m, ok := Render("notify", notifyPayload(tc.subKind), "en")
+			if ok != tc.wantOK {
+				t.Fatalf("ok = %v, want %v", ok, tc.wantOK)
+			}
+			if ok && m.StartParam != "" {
+				t.Errorf("StartParam = %q, want empty (lobby)", m.StartParam)
+			}
+		})
+	}
+}
+
+func TestRenderSkipsUnpushedKinds(t *testing.T) {
+	for _, kind := range []string{"opponent_moved", "chat_message", "unknown"} {
+		if _, ok := Render(kind, nil, "en"); ok {
+			t.Errorf("kind %q: ok = true, want false", kind)
+		}
+	}
+}