feat(telegram): split connector into home validator + remote bot

Move all Telegram egress off the main host. The single connector held the
bot token, long-polled Telegram and answered the gateway/backend over the
trusted internal network, so the whole component (including login validation)
shared fate with its VPN sidecar. Split it into two binaries that share the
token:

- cmd/validator (home, no VPN): Mini App initData + Login Widget HMAC only,
  never calls the Bot API. The gateway dials it for Telegram auth, so game
  login is now independent of Telegram reachability.
- cmd/bot (remote): Bot API long-poll + sendMessage, the only component
  reaching Telegram. It holds no inbound port — it dials the gateway over a
  new reverse mTLS bot-link (pkg/proto/botlink/v1) and executes the send
  commands the gateway pushes.

The gateway funnels sends to the bot-link: out-of-app push is fire-and-forget
(at-most-once, dropped if no bot is connected); the backend admin broadcasts
reach a gateway-served relay that forwards them and awaits the bot's ack
(SendToUser/SendToGameChannel contract preserved). mTLS (pkg/mtls) is the one
inter-service link that leaves the trusted segment; validator<->gateway and
the relay stay plaintext internal. The bot is Telegram-rate-limited.

One bot now; the gateway bot registry, an owns_updates flag and per-command
ids leave seams for N later. Webhook rejected (one URL per token, adds inbound
+ a static address).

The unified test contour runs the split (the bot keeps its VPN sidecar and
dials the gateway by its internal name; bot-link certs from deploy/gen-certs.sh,
generated in CI). The prod wiring — the bot on a separate host (no VPN), the
gateway bot-link port published, PROD_ certs with scheduled rotation, an SSH
deploy of both hosts together — is the deferred final stage (PRERELEASE.md TX,
Stage 18).

Docs: ARCHITECTURE, PRERELEASE (phase TX), platform/telegram + gateway +
backend + deploy READMEs, FUNCTIONAL(+ru), CLAUDE.md, .env.example.

platform/telegram/internal/botlink/client.go

@@ -0,0 +1,131 @@
+package botlink
+
+import (
+	"context"
+	"time"
+
+	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/keepalive"
+
+	botlinkv1 "scrabble/pkg/proto/botlink/v1"
+)
+
+const (
+	// clientKeepaliveTime is how often the bot pings the gateway to hold the WAN
+	// connection open (kept above the gateway's MinTime to avoid an enforcement ban).
+	clientKeepaliveTime = 30 * time.Second
+	// clientKeepaliveTimeout bounds the wait for a keepalive ping reply.
+	clientKeepaliveTimeout = 10 * time.Second
+)
+
+// ClientConfig configures the bot's dial side of the reverse bot-link.
+type ClientConfig struct {
+	// GatewayAddr is the gateway bot-link endpoint to dial.
+	GatewayAddr string
+	// InstanceID identifies this bot to the gateway.
+	InstanceID string
+	// OwnsUpdates reports whether this bot runs the exclusive getUpdates long-poll.
+	OwnsUpdates bool
+	// Creds is the transport credentials for the dial (mutual TLS in production,
+	// built from pkg/mtls).
+	Creds credentials.TransportCredentials
+	// ReconnectDelay is the pause before re-dialing after the stream ends.
+	ReconnectDelay time.Duration
+}
+
+// Client maintains the long-lived bot-link to the gateway, executing the commands
+// it receives and re-dialing after any break.
+type Client struct {
+	cfg  ClientConfig
+	exec *Executor
+	log  *zap.Logger
+}
+
+// NewClient builds the bot-link client over the executor.
+func NewClient(cfg ClientConfig, exec *Executor, log *zap.Logger) *Client {
+	if log == nil {
+		log = zap.NewNop()
+	}
+	return &Client{cfg: cfg, exec: exec, log: log}
+}
+
+// Run dials the gateway and keeps the bot-link open, re-dialing after each break,
+// until ctx is cancelled. The gRPC connection auto-reconnects the transport; this
+// loop re-opens the Link stream on top of it.
+func (c *Client) Run(ctx context.Context) error {
+	conn, err := grpc.NewClient(c.cfg.GatewayAddr,
+		grpc.WithTransportCredentials(c.cfg.Creds),
+		grpc.WithStatsHandler(otelgrpc.NewClientHandler()),
+		grpc.WithKeepaliveParams(keepalive.ClientParameters{
+			Time:                clientKeepaliveTime,
+			Timeout:             clientKeepaliveTimeout,
+			PermitWithoutStream: true,
+		}),
+	)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Close() }()
+	client := botlinkv1.NewBotLinkClient(conn)
+
+	for ctx.Err() == nil {
+		if err := c.serve(ctx, client); err != nil && ctx.Err() == nil {
+			c.log.Warn("bot-link stream ended", zap.Error(err))
+		}
+		if !sleep(ctx, c.cfg.ReconnectDelay) {
+			break
+		}
+	}
+	return ctx.Err()
+}
+
+// serve opens one Link stream, registers with a Hello, then executes commands and
+// replies with an Ack each until the stream ends.
+func (c *Client) serve(ctx context.Context, client botlinkv1.BotLinkClient) error {
+	stream, err := client.Link(ctx)
+	if err != nil {
+		return err
+	}
+	if err := stream.Send(&botlinkv1.FromBot{Msg: &botlinkv1.FromBot_Hello{Hello: &botlinkv1.Hello{
+		InstanceId:  c.cfg.InstanceID,
+		OwnsUpdates: c.cfg.OwnsUpdates,
+	}}}); err != nil {
+		return err
+	}
+	c.log.Info("bot-link connected", zap.String("gateway", c.cfg.GatewayAddr), zap.Bool("owns_updates", c.cfg.OwnsUpdates))
+
+	for {
+		msg, err := stream.Recv()
+		if err != nil {
+			return err
+		}
+		cmd := msg.GetCommand()
+		if cmd == nil {
+			continue
+		}
+		delivered, herr := c.exec.Handle(ctx, cmd)
+		ack := &botlinkv1.Ack{CommandId: cmd.GetCommandId(), Delivered: delivered}
+		if herr != nil {
+			ack.Error = herr.Error()
+		}
+		if err := stream.Send(&botlinkv1.FromBot{Msg: &botlinkv1.FromBot_Ack{Ack: ack}}); err != nil {
+			return err
+		}
+	}
+}
+
+// sleep waits for d or until ctx is cancelled, reporting whether it waited the full
+// duration.
+func sleep(ctx context.Context, d time.Duration) bool {
+	t := time.NewTimer(d)
+	defer t.Stop()
+	select {
+	case <-ctx.Done():
+		return false
+	case <-t.C:
+		return true
+	}
+}