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.

ui/src/lib/deeplink.ts

@@ -0,0 +1,49 @@
+// Telegram Mini App deep-link "start parameters", mirroring the connector's Go
+// scheme (platform/telegram/internal/deeplink): a one-character kind prefix plus a
+// value —
+//   g<game uuid>        open that game
+//   i<invitation uuid>  open that invitation
+//   f<6-digit code>     redeem that friend code
+// An empty or unrecognised parameter opens the lobby.
+
+export type DeepLink =
+  | { kind: 'lobby' }
+  | { kind: 'game'; id: string }
+  | { kind: 'invitation'; id: string }
+  | { kind: 'friendCode'; code: string };
+
+/** parseStartParam classifies a Telegram start parameter into a routing target. */
+export function parseStartParam(param: string | undefined | null): DeepLink {
+  if (!param) return { kind: 'lobby' };
+  const value = param.slice(1);
+  if (!value) return { kind: 'lobby' };
+  switch (param[0]) {
+    case 'g':
+      return { kind: 'game', id: value };
+    case 'i':
+      return { kind: 'invitation', id: value };
+    case 'f':
+      return { kind: 'friendCode', code: value };
+    default:
+      return { kind: 'lobby' };
+  }
+}
+
+/** gameParam builds the start parameter that opens a game. */
+export const gameParam = (id: string): string => 'g' + id;
+/** invitationParam builds the start parameter that opens an invitation. */
+export const invitationParam = (id: string): string => 'i' + id;
+/** friendCodeParam builds the start parameter that redeems a friend code. */
+export const friendCodeParam = (code: string): string => 'f' + code;
+
+/**
+ * shareLink wraps a deep-link start parameter in a t.me Mini App link, using the
+ * VITE_TELEGRAM_LINK base (e.g. https://t.me/<bot>/<app>). It returns null when the
+ * base is not configured, so callers can hide the share affordance.
+ */
+export function shareLink(param: string): string | null {
+  const base = import.meta.env.VITE_TELEGRAM_LINK as string | undefined;
+  if (!base) return null;
+  const sep = base.includes('?') ? '&' : '?';
+  return `${base}${sep}startapp=${encodeURIComponent(param)}`;
+}