refactor(frontend): honest effect deps in the app shell and the ui layer (E27 S2)

Burns the first 14 of the 113 hook suppressions. Three verdicts, applied per site:

A useEffect that should not exist (6):
- Avatar remembered "the image failed" as a boolean an effect reset on src change. The
  component is recycled across items in the virtualized feed, so after one avatar 429s the
  next item's slot committed the fallback initial over a perfectly good image and only the
  post-paint effect cleared it. The failure is now keyed BY URL; derived state cannot be stale.
- Combobox cleared the typed query from an effect on `open`. Moved into setOpenAnd, the single
  funnel every close goes through. That also stops a spurious onQueryChange("") AT MOUNT, which
  told a controlled caller its own initial query had been cleared before the user touched it.
- CommandPalette reset query + picked row from an effect. Closed now means UNMOUNTED, not
  hidden, so a fresh open starts blank because mounting already means that -- and the ranking
  memo over every channel, playlist and saved view stops running while the palette is shut.
- Pager's page box held a copy of the page that an effect re-synced; it now derives it and
  keeps a draft only while being edited.
- App's ?link= / ?oauth= / ?admin= one-shots asserted "once per mount" with an empty dep list.
  The ref guard the codebase already uses in 22 places ENFORCES it, so the honest deps can
  include `t` -- which a language switch legitimately changes, and which would otherwise have
  re-fired the toast.

Honest deps that also fix something (5):
- App's module preload was keyed on the account id, so a permission change that alters the
  module set without moving the id never re-preloaded. `preload()` is idempotent, so depending
  on `me` costs nothing.
- App's access-request nudge now re-issues on a language switch; it used to stay in the old
  language until the pending count changed.
- App's diagnostics effect: applyDiagnostics already no-ops on an unchanged effective level,
  so picking four fields out by hand was guarding nothing and missed any field added later.
- DataTable's two filter effects: a ref holds the latest onFiltersChange so commitFilters can
  be stable, which is what lets the effects name it instead of switching the check off.

Genuine escape hatches (7) moved OUT of eslint-suppressions.json into inline directives that
name the invariant at the site -- the toast handover's render-phase global, the live region's
deliberate arming tick, the docked one-slot component, the popover engine's floating-ui list
state, dnd-kit's per-drag `moved` flag, BackToTop's DOM read and the palette's debounced
announcement. A reader of the code now sees why; a JSON file no one opens does not.

Tests: Avatar (3, new file) and Pager (3) pin the derived-state frames with a layout-phase
probe -- layout effects run before any passive effect, so they read the frame the browser would
paint. Combobox (2) pins the close-clears-query contract and the no-callback-at-mount rule.
All three sets mutation-checked against the effect-based originals.

Suppressions 113 -> 99; exhaustive-deps 45 -> 35.

frontend/src/components/ui/Avatar.dom.test.tsx

@@ -0,0 +1,64 @@
+// @vitest-environment jsdom
+import { useLayoutEffect } from "react";
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+
+import Avatar from "./Avatar";
+
+afterEach(cleanup);
+
+// The failure state is keyed by URL rather than held as a boolean an effect resets, and the reason
+// is a frame the user could see: Avatar is recycled across items in the virtualized feed, so after
+// ONE image 429s (Google's avatar CDNs throttle bursts — see the component's own note), the next
+// item to land in that slot rendered with its new `src` and the previous item's `failed`. The
+// fallback initial was therefore committed and painted over a perfectly good image, and only the
+// post-paint effect put it right.
+//
+// `useLayoutEffect` is what makes that observable instead of a race: layout effects run against the
+// committed DOM BEFORE any passive effect, so the snapshot it takes is exactly the frame the browser
+// would paint — the one the old reset effect had not repaired yet.
+function Probe({ src, painted }: { src: string; painted: string[] }) {
+  useLayoutEffect(() => {
+    painted.push(document.body.innerHTML);
+  });
+  return <Avatar src={src} alt="avatar" fallback="Zed" />;
+}
+
+describe("Avatar · a failed image must not follow the component to the next item", () => {
+  it("shows the new src in the SAME commit that changes it, with no fallback frame between", () => {
+    const painted: string[] = [];
+    const { rerender } = render(<Probe src="https://cdn.test/a.jpg" painted={painted} />);
+
+    fireEvent.error(screen.getByRole("img", { name: "avatar" }));
+    expect(screen.queryByRole("img")).toBeNull();
+    expect(screen.getByText("Z")).toBeTruthy();
+
+    painted.length = 0;
+    rerender(<Probe src="https://cdn.test/b.jpg" painted={painted} />);
+
+    // The FIRST frame after the src change already carries the image. Reading the last snapshot
+    // instead would let a passive-effect repair pass, which is precisely the bug.
+    expect(painted.length).toBeGreaterThan(0);
+    expect(painted[0]).toContain("https://cdn.test/b.jpg");
+    expect(painted[0]).not.toContain(">Z<");
+  });
+
+  it("keeps the fallback for the URL that actually failed, not for whatever is current", () => {
+    const { rerender } = render(
+      <Avatar src="https://cdn.test/a.jpg" alt="avatar" fallback="Zed" />,
+    );
+    fireEvent.error(screen.getByRole("img", { name: "avatar" }));
+    expect(screen.getByText("Z")).toBeTruthy();
+
+    rerender(<Avatar src="https://cdn.test/b.jpg" alt="avatar" fallback="Zed" />);
+    expect(screen.getByRole("img", { name: "avatar" }).getAttribute("src")).toBe(
+      "https://cdn.test/b.jpg",
+    );
+  });
+
+  it("falls back when there is no src at all", () => {
+    render(<Avatar src={null} alt="avatar" fallback="Zed" />);
+    expect(screen.queryByRole("img")).toBeNull();
+    expect(screen.getByText("Z")).toBeTruthy();
+  });
+});