feat(export): server-rendered artifacts behind one signed download URL (#160)

The finished-game export (GCG + a new PNG of the final position) is one
signed, short-lived relative URL (game.export_url; HMAC-SHA256, 10-min
TTL, BACKEND_EXPORT_SIGN_KEY) resolved against the client's own origin
and delivered by the best affordance each platform has (five on-device
review rounds):

- TG Android/desktop: native showPopup chooser -> native downloadFile
  dialog (bridge-only chain, activation-safe).
- TG iOS: app-modal chooser -> OS share sheet with the fetched file
  (a popup callback cannot supply the activation the sheet needs).
- VK iOS: VKWebAppDownloadFile for both formats.
- VK Android: the PNG opens in VK's native image viewer, the GCG copies
  to the clipboard (the VK Android downloader hangs on any download,
  Content-Length/Range notwithstanding).
- VK desktop iframe / desktop browsers: plain anchor downloads.
- Mobile browsers: the OS share sheet (fetch-then-share).
- Legacy TG (< Bot API 8.0): app modal + GCG clipboard, no image option.

The PNG is rasterized on demand by the new internal `renderer` sidecar
(node:22-slim + skia-canvas + baked Liberation/Noto Color Emoji fonts)
executing the SAME ui/src/lib/gameimage.ts the ui project unit-tests;
the backend rebuilds the render payload from the journal +
engine.AlphabetTable, and the device date locale, IANA time zone and
localized non-play labels ride the signed URL. Nothing is stored — the
artifact re-derives from the immutable journal on each GET. The gateway
forwards /dl/* (caddy @gateway matcher extended) behind the per-IP
public rate limiter and serves bytes via http.ServeContent.

Deploy: renderer service in compose + prod overlay + rolling order +
prod push list; TEST_/PROD_EXPORT_SIGN_KEY secrets; the sidecar smoke
runs in the ui CI job. Docs: ARCHITECTURE, FUNCTIONAL(+_ru), UI_DESIGN,
TESTING, deploy/README, renderer/README.

renderer/src/server.mjs

@@ -0,0 +1,55 @@
+// The render sidecar: a minimal internal HTTP service the backend calls to rasterize the
+// finished-game export image. It runs the same drawGameImage the browser build ships
+// (bundled from ui/src/lib at image build time) on skia-canvas, with system fonts from
+// the image (Liberation Sans + Noto Color Emoji via fontconfig).
+//
+//   POST /render  {game, moves, alphabet, labels, dateLocale, hostname, scale?} → image/png
+//   GET  /healthz → 200
+//
+// The service is internal-only (docker network `internal`); authentication, participant
+// checks and the signed public URL all live in the backend — this process only draws.
+import { createServer } from 'node:http';
+import { renderRequest } from './render.mjs';
+
+const PORT = Number(process.env.RENDERER_PORT || 8090);
+// A render request is a finished game's journal — generously capped.
+const MAX_BODY = 2 * 1024 * 1024;
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > MAX_BODY) {
+        reject(Object.assign(new Error('body too large'), { status: 413 }));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+const server = createServer(async (req, res) => {
+  try {
+    if (req.method === 'GET' && req.url === '/healthz') {
+      res.writeHead(200, { 'content-type': 'text/plain' }).end('ok');
+      return;
+    }
+    if (req.method === 'POST' && req.url === '/render') {
+      const png = await renderRequest(JSON.parse(await readBody(req)));
+      res.writeHead(200, { 'content-type': 'image/png', 'content-length': png.length }).end(png);
+      return;
+    }
+    res.writeHead(404).end();
+  } catch (err) {
+    const status = err.status || (err instanceof SyntaxError ? 400 : 500);
+    console.error(`render error: ${err.message}`);
+    res.writeHead(status, { 'content-type': 'text/plain' }).end('render failed');
+  }
+});
+
+server.listen(PORT, () => console.log(`renderer listening on :${PORT}`));