Add an English/Czech interface language switch

English stays the default; Czech is a full translation. Only the app chrome
is translated - notes and generated decks keep their own language, which is a
core feature, not a setting.

i18n
- lib/i18n-dict.ts: flat en/cs dictionaries (441 keys each), translate() and
  translatePlural() with real Czech plural rules (1 sada / 2-4 sady / 5+ sad).
  English is the default and the fallback for a missing key.
- lib/i18n.ts: browser store (freezmo.locale.v1), useI18n() hook, and the
  x-freezmo-locale header. The hook's t/plural are bound to the locale React
  is rendering with, so the first client render matches the server HTML and
  then re-renders in the stored language; module-level t is only for event
  handlers and non-React helpers.
- <html lang> follows the choice (inline script + setLocale).

UI
- Settings -> Language segmented control (English / Cestina), plus an EN/CS
  button on the key gate for first run.
- Every screen translated: sidebar, header, tab bar, library, deck cards,
  folder bar, create flow, all seven activities, study chrome, results,
  settings + health panel, API-key gate and help, install sheet, offline and
  the deck-not-found page.
- Plural-aware counts everywhere (decks, folders, activities, runs, photos,
  documents, pages, words, wrong attempts).

Server
- API routes and guards (generate, grade, health, http-guard, rate-limit,
  ollama error mapping) answer in the request's language, so error cards and
  the health panel never fall back to English mid-sentence.

Fixes
- A hydration mismatch when a non-default locale was stored silently dropped
  the .dark class after hydration; render-time t() is now bound to the
  hook's locale (UploadScreen.describeExtraction, ResultsScreen.answerFor,
  DeckCard's folder fallback).
- Bumped the service worker cache to freezmo-v4 for this deploy.

Tests: i18n 27/27 (gate toggle, persistence, html lang, Czech plurals,
settings switch) and a rebuilt regression suite 72/72 (English default,
library, create, all 7 activity types, results, settings, install sheet,
offline, PWA, security, Czech smoke).

lib/i18n.ts

@@ -0,0 +1,127 @@
+"use client";
+
+/**
+ * Browser-side locale store + React bindings.
+ *
+ * English is the default and the source of truth; Czech is a full translation.
+ * Only *interface* copy lives in the dictionaries — your notes and the generated
+ * decks always keep their own language (that is a core feature, not a setting).
+ *
+ * The dictionaries themselves live in ./i18n-dict so the server can translate
+ * its API messages into the same language.
+ */
+
+import { useSyncExternalStore } from "react";
+
+import {
+  DEFAULT_LOCALE,
+  LOCALE_HEADER,
+  LOCALES,
+  normaliseLocale,
+  translate,
+  translatePlural,
+  type Locale,
+  type Vars,
+} from "./i18n-dict";
+
+export { LOCALES, DEFAULT_LOCALE, LOCALE_HEADER, translate, translatePlural };
+export type { Locale };
+
+const STORAGE_KEY = "freezmo.locale.v1";
+
+let cached: Locale | null = null;
+const listeners = new Set<() => void>();
+
+function read(): Locale {
+  if (typeof window === "undefined") return DEFAULT_LOCALE;
+  try {
+    return normaliseLocale(window.localStorage.getItem(STORAGE_KEY));
+  } catch {
+    return DEFAULT_LOCALE;
+  }
+}
+
+function emit(): void {
+  listeners.forEach((listener) => listener());
+}
+
+export const localeStore = {
+  subscribe(listener: () => void): () => void {
+    listeners.add(listener);
+    const onStorage = (event: StorageEvent) => {
+      if (event.key === STORAGE_KEY) {
+        cached = read();
+        emit();
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    return () => {
+      listeners.delete(listener);
+      window.removeEventListener("storage", onStorage);
+    };
+  },
+  getSnapshot(): Locale {
+    if (cached === null) cached = read();
+    return cached;
+  },
+  getServerSnapshot(): Locale {
+    return DEFAULT_LOCALE;
+  },
+};
+
+export function getLocale(): Locale {
+  return localeStore.getSnapshot();
+}
+
+export function setLocale(locale: Locale): void {
+  cached = normaliseLocale(locale);
+  try {
+    window.localStorage.setItem(STORAGE_KEY, cached);
+  } catch {
+    /* private mode */
+  }
+  try {
+    document.documentElement.lang = cached;
+  } catch {
+    /* SSR */
+  }
+  emit();
+}
+
+/** React hook: re-renders when the locale changes. */
+export function useLocale(): Locale {
+  return useSyncExternalStore(localeStore.subscribe, localeStore.getSnapshot, localeStore.getServerSnapshot);
+}
+
+/** Translate a key for the current locale. */
+export function t(key: string, vars?: Vars): string {
+  return translate(localeStore.getSnapshot(), key, vars);
+}
+
+/** Plural-aware translate for the current locale. */
+export function plural(n: number, base: string, vars?: Vars): string {
+  return translatePlural(localeStore.getSnapshot(), n, base, vars);
+}
+
+/** Header handed to our own API routes so they answer in the chosen language. */
+export function localeHeader(): Record<string, string> {
+  return { [LOCALE_HEADER]: localeStore.getSnapshot() };
+}
+
+/**
+ * Convenience hook for components.
+ *
+ * `t` / `plural` are bound to the locale React is currently rendering with
+ * (the server snapshot during hydration, then the stored choice), so the first
+ * client render always matches the server HTML. Use the module-level `t` only
+ * in event handlers and non-React helpers.
+ */
+export function useI18n() {
+  const locale = useLocale();
+  return {
+    locale,
+    setLocale,
+    t: (key: string, vars?: Vars) => translate(locale, key, vars),
+    plural: (n: number, base: string, vars?: Vars) => translatePlural(locale, n, base, vars),
+  };
+}