Stage 6: gateway edge (Connect/FlatBuffers over h2c, platform/email/guest auth, sessions, rate-limit, admin passthrough, live push bridge)

New public ingress and the first network edge. Framework + a vertical slice of
operations end-to-end; remaining ops reuse the same transcode pattern in Stage 7.

Contracts (new module scrabble/pkg):
- push.proto (backend->gateway gRPC server-stream) + scrabble.fbs (FlatBuffers
  edge payloads), committed generated Go; buf/flatc Makefiles (dev-time codegen).

Backend:
- REST handlers on the /api/v1 groups: internal session endpoints
  (telegram/guest/email login -> mint, resolve, revoke) and the user slice
  (profile, submit_play, state, lobby enqueue/poll, chat).
- internal/notify in-process Publisher hub + internal/pushgrpc gRPC server
  (BACKEND_GRPC_ADDR) streaming your_turn/opponent_moved/chat/nudge/match_found;
  emission in game.commit, social, matchmaker.
- migration 00005 accounts.is_guest; guests are durable rows excluded from stats;
  ProvisionGuest; email-as-login (RequestLoginCode/LoginWithCode).

Gateway (new module scrabble/gateway):
- Connect Gateway service over h2c (Execute + Subscribe), FlatBuffers<->JSON
  transcode registry, Telegram initData HMAC validator (seam), session cache,
  token-bucket rate limiter (3 classes), push fan-out hub, backend REST + push
  gRPC client, admin Basic-Auth reverse proxy.

go.work: use ./pkg, ./gateway + replace scrabble/pkg. CI: gateway/**, pkg/**
path filters; unit build/vet/test span all three modules. Docs (PLAN,
ARCHITECTURE, FUNCTIONAL+ru, TESTING, READMEs) updated; gateway/pkg unit tests +
guest/email-login integration tests.

backend/cmd/backend/main.go

@@ -22,7 +22,9 @@ import (
 	"scrabble/backend/internal/engine"
 	"scrabble/backend/internal/game"
 	"scrabble/backend/internal/lobby"
+	"scrabble/backend/internal/notify"
 	"scrabble/backend/internal/postgres"
+	"scrabble/backend/internal/pushgrpc"
 	"scrabble/backend/internal/robot"
 	"scrabble/backend/internal/server"
 	"scrabble/backend/internal/session"
@@ -58,6 +60,12 @@ func main() {
 // turn-timeout sweeper), the robot opponent (pool + move driver) and the
 // matchmaking reaper, HTTP server — and blocks until ctx is cancelled.
 func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
+	// A cancellable child context so the first server (or signal) to stop tears
+	// the rest down — the HTTP and gRPC listeners and every background worker
+	// share it.
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
 	tel, err := telemetry.New(ctx, cfg.Telemetry)
 	if err != nil {
 		return fmt.Errorf("init telemetry: %w", err)
@@ -99,8 +107,14 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	}
 	logger.Info("session cache warmed")
 
+	// The in-process live-event hub fans domain intents out to the gRPC push
+	// stream. It is installed on every emitting service before any background
+	// worker starts so robot moves and timeout sweeps also emit.
+	hub := notify.NewHub(0)
+
 	accounts := account.NewStore(db)
 	games := game.NewService(game.NewStore(db), accounts, registry, cfg.Game, logger)
+	games.SetNotifier(hub)
 	go games.RunSweeper(ctx, cfg.Game.TimeoutSweepInterval)
 	logger.Info("game turn-timeout sweeper started",
 		zap.Duration("interval", cfg.Game.TimeoutSweepInterval))
@@ -111,6 +125,7 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	mailer := newMailer(cfg.SMTP, logger)
 	emails := account.NewEmailService(accounts, mailer)
 	socialSvc := social.NewService(social.NewStore(db), accounts, games)
+	socialSvc.SetNotifier(hub)
 
 	// Stage 5 robot opponent: provision its durable account pool (a hard startup
 	// dependency, like the dictionaries) and start its move driver. The matchmaker
@@ -123,6 +138,7 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 	logger.Info("robot driver started", zap.Duration("interval", cfg.Robot.DriveInterval))
 
 	matchmaker := lobby.NewMatchmaker(games, robots, cfg.Lobby.RobotWait, logger)
+	matchmaker.SetNotifier(hub)
 	go matchmaker.RunReaper(ctx, cfg.Lobby.ReaperInterval)
 	invitations := lobby.NewInvitationService(lobby.NewStore(db), games, accounts, socialSvc)
 	logger.Info("lobby and social domains ready", zap.Duration("robot_wait", cfg.Lobby.RobotWait))
@@ -132,12 +148,28 @@ func run(ctx context.Context, cfg config.Config, logger *zap.Logger) error {
 		DB:            db,
 		PingTimeout:   cfg.Postgres.OperationTimeout,
 		SessionsReady: sessions.Ready,
+		Sessions:      sessions,
+		Accounts:      accounts,
+		Games:         games,
 		Social:        socialSvc,
 		Matchmaker:    matchmaker,
 		Invitations:   invitations,
 		Emails:        emails,
 	})
-	return srv.Run(ctx)
+	pushSrv := pushgrpc.NewServer(cfg.GRPCAddr, hub, logger)
+
+	// Run the HTTP and gRPC push listeners together; the first to stop (a listen
+	// error, or ctx cancellation on signal) tears down the other through cancel.
+	logger.Info("servers starting",
+		zap.String("http_addr", cfg.HTTPAddr),
+		zap.String("grpc_addr", cfg.GRPCAddr))
+	errc := make(chan error, 2)
+	go func() { errc <- pushSrv.Run(ctx) }()
+	go func() { errc <- srv.Run(ctx) }()
+	err = <-errc
+	cancel()
+	<-errc
+	return err
 }
 
 // newMailer builds the confirm-code mailer: an SMTP relay when a host is