fix(boot): a new tab knows its account before anything renders

With Settings -> Appearance -> Startup turned off, every NEW tab or window still
opened on Home; only a same-tab reload honoured it. The provider tree mounted
before /api/me answered, so NavigationProvider's initializer could not read the
per-account opt-out, landed on Home and mirrored ?page=home into the address bar.
When App pinned the account a moment later, the re-hydrate re-read that mirror
and stayed on Home. The same mount-then-patch shape made a new tab start on
default filters, the default theme and the browser language, and correct each
after the first paint.

BootGate (main.tsx, above the providers) now owns the setup-status and /api/me
queries and mounts the tree only once the identity is settled: it pins the tab's
account and adopts the account's language in a layout effect, so the first frame
of the app is already right. The tree is keyed on the account id, which makes
"per-account state is read once, for this account" a structural guarantee.

With that, the whole re-hydrate machinery is gone: useAccountRehydrate, the
reactive active-account store, the markDirty guards, the pin-deferred saved-view
seed and the present-dimension bookkeeping of the shared Channels/Plex links.
PrefsProvider, FeedFiltersProvider, usePref and App's panel layouts seed from the
me cache instead of adopting it in an effect; the theme is applied in layout
effects. The app chunk is fetched in parallel with the probe, and the boot screen
only fades its label in after 400 ms, on one clock across the gate and the
Suspense fallback.

Module switches no longer flash a placeholder either. Measured frame by frame
in Chromium and WebKit, every first visit to a module showed "Loading..." for
17-70 ms: the lazy chunk's Suspense fallback, then often the first fetch's
LoadingState. Pages are now lazyWithPreload components, and App fetches the
chunks of every module the account can reach (plus the channel page) once the
first page is idle; a preloaded page renders synchronously and never suspends.
LoadingState, the one shared loading visual, fades in only after 300 ms, so a
fast load shows nothing in between and a slow one still gets its spinner.

frontend/src/lib/storage.ts

@@ -1,6 +1,5 @@
 import { useCallback, useState } from "react";
 import { activeAccountId } from "./activeAccount";
-import { useAccountRehydrate } from "./useAccountRehydrate";
 
 // Central registry of every localStorage key the app uses. One place to see them all, rename
 // safely, and avoid collisions — instead of `"siftlode.x"` string literals scattered across
@@ -16,15 +15,13 @@ export const LS = {
   filters: "siftlode.filters",
   page: "siftlode.page",
   // E24: start every session on the Home surface rather than on the module you happened to leave
-  // open. Per-account, "0" = opt out and go back to remembering the last module. It has to be
-  // localStorage rather than a server pref because `loadInitialPage` runs before /api/me lands —
-  // a landing page decided after the first paint would be a visible jump.
+  // open. Per-account, "0" = opt out and go back to remembering the last module. Read by
+  // `loadInitialPage` in NavigationProvider's initializer, which BootGate runs only once the tab's
+  // account is pinned — so the landing is decided right before the first paint, never corrected after.
   startOnHome: "siftlode.startOnHome",
   perfMode: "siftlode.perfMode",
-  // The feed's view mode (see lib/feedView.ts) — a cache of the server pref, so a reload of an
-  // established tab paints your view straight away. A brand-new tab still starts on the default
-  // until /api/me lands: the account isn't pinned yet (App pins it once meQuery resolves), so
-  // the per-account key can't be read.
+  // The feed's view mode (see lib/feedView.ts) — a local copy of the server pref, which usePref seeds
+  // from only when the server has never stored the key.
   feedView: "siftlode.feedView",
   // The subscribed table's column filters (a FilterMap), lifted out of the table so the top status
   // chips, the Sync column funnel, and the card layout all share ONE state (per-account). Supersedes
@@ -72,7 +69,7 @@ export const LS = {
 } as const;
 
 // --- per-account scoping -----------------------------------------------------------------
-// The active-account primitive (activeAccountId / useActiveAccountId / notify) lives in ./activeAccount
+// The active-account primitive (activeAccountId) lives in ./activeAccount
 // so it can be shared without a cycle; the helpers below key localStorage on it.
 
 /** Suffix a base localStorage key with an account id so per-account UI state (filters, selected
@@ -154,24 +151,21 @@ export function writeJSON(key: string, value: unknown): void {
 /** A `useState` whose string value is mirrored to localStorage, scoped to the current account (see
  * accountKey), so one account's persisted tab/view position doesn't carry over to another in the
  * same browser. Survives reload (F5); validation is deferred to the caller (clamp at render) so it
- * can be used before an async-loaded option list is known, keeping hook order stable. Consumers
- * usually mount only once signed in (account known), but re-read on the account-pin transition too so
- * one that mounts before the pin (a fresh tab's first paint) still restores. */
+ * can be used before an async-loaded option list is known, keeping hook order stable. Read once, at
+ * mount: BootGate mounts every consumer after the account is pinned. */
 export function useAccountPersistedState(
   base: string,
   fallback = "",
 ): [string, (value: string) => void] {
   const [value, setValue] = useState<string>(() => getAccountRaw(base) ?? fallback);
-  const markDirty = useAccountRehydrate(() => setValue(getAccountRaw(base) ?? fallback));
-  // Stable setter (base + markDirty are both stable) so a provider can build a stable action on top
-  // of it — e.g. ChannelsProvider's setView, which must not change identity on every tab switch.
+  // Stable setter (base is stable) so a provider can build a stable action on top of it — e.g.
+  // ChannelsProvider's setView, which must not change identity on every tab switch.
   const set = useCallback(
     (next: string) => {
-      markDirty();
       setValue(next);
       setAccountRaw(base, next);
     },
-    [base, markDirty],
+    [base],
   );
   return [value, set];
 }
@@ -184,17 +178,15 @@ export function useAccountPersistedObject<T extends object>(
   defaults: T,
 ): [T, (patch: Partial<T>) => void] {
   const [value, setValue] = useState<T>(() => readAccountMerged(base, defaults));
-  const markDirty = useAccountRehydrate(() => setValue(readAccountMerged(base, defaults)));
   const patch = useCallback(
     (p: Partial<T>) => {
-      markDirty();
       setValue((prev) => {
         const next = { ...prev, ...p };
         writeAccount(base, next);
         return next;
       });
     },
-    [base, markDirty],
+    [base],
   );
   return [value, patch];
 }