fix(e24): review round 3 — the holes round 2's own fixes left

Round 3 reviewed the round-2 commit across six dimensions. Fifteen findings, five survived
three adversarial refuters each; three died on 2+ refutations (a keyboard-focus claim that
is a property of `ui/Button` at all six of its `loading` call sites, a contract-test
false-pass that needs a deliberate revert plus a self-incriminating comment, and a
MAX_EXCLUDE coupling whose slice is unreachable from the real client).

- `rerolling` was still wrong for a FAILED press. `data === undefined` is true forever for a
  key whose request failed (`retry: false`), so the next unrelated mutation re-disabled the
  reroll button — the same defect round 2 reported, one branch over. `!isFetched` is the
  flag that remembers a key settled; `!isError` would not have worked, because query-core
  resets a data-less query to "pending" for the duration of a refetch, hiding the error
  exactly when it matters.
- The hero fallback used `??`, which cannot tell "this budget's last pick resolved to NO
  hero" from "nothing remembered". So a press that failed after an empty one resurrected the
  card the page had already excluded as seen and just said it had nothing beyond. The tagged
  slot is now authoritative for its own budget.
- `setPage`'s boolean — the input the whole burial rule reads — was asserted by nothing.
  The type fences the SHAPE, so deleting a `return` fails tsc, but swapping the two values
  passed typecheck and all 822 tests. NavigationProvider gets its first render test, on the
  value AND on the effects the early return skips.
- `closeThenNavigate`'s door into `buryUnder` was equally unpinned: reverting that one call
  site to the old unconditional burial left the suite green. It has the mirror case now.
- The comment claiming one rule serves both entry points was overstated. `buryUnder` fails
  OPEN, and `CommandItem.run` is typed `() => void`, so only the palette's bare
  `() => setPage(page)` rows forward the boolean at all. Nothing regressed — that path buried
  unconditionally before — but the prose said more than the code does, so it now says what is
  true and points at the deferred fix. Same for a "the only assertion in the suite" claim
  that the file it cites as precedent also makes.

Every new test mutation-checked red for the right reason, both edges where there are two.
Gate: ruff, ruff format, 3x tsc, eslint (0 errors), prettier, knip, vitest 828, pytest 1005.

frontend/src/lib/history.dom.test.ts

@@ -152,6 +152,37 @@ describe("closeThenNavigate", () => {
     }
   });
 
+  // The mirror of the case above, and the OTHER door into `buryUnder` — round 3 found that only
+  // `navigateOverOverlays` was pinned, so this call site could be reverted to the old unconditional
+  // burial with the whole suite green. Reachable through the palette: `run: () => setPage(page)` is
+  // a bare arrow, so `setPage`'s `false` really does arrive here when the chosen module is the one
+  // already on screen. Nothing was pushed, so the layer underneath is still ours to reclaim.
+  it("leaves the layer below reclaimable when the command navigated nowhere", async () => {
+    const back = vi.spyOn(window.history, "back").mockImplementation(() => {
+      window.dispatchEvent(new PopStateEvent("popstate", { state: window.history.state }));
+    });
+    try {
+      const player = renderHook(() => useBackToClose(() => {}));
+      await settle();
+      const palette = renderHook(() => useBackToClose(() => {}));
+      await settle();
+
+      const navigate = vi.fn(() => false); // setPage's early return: already on that page
+      await act(async () => {
+        closeThenNavigate(() => palette.unmount(), navigate);
+        await Promise.resolve();
+      });
+      expect(navigate).toHaveBeenCalledTimes(1);
+      expect(back).toHaveBeenCalledTimes(1); // the palette's own entry
+
+      player.unmount();
+      await settle();
+      expect(back).toHaveBeenCalledTimes(2); // and the player's, because nothing was pushed over it
+    } finally {
+      back.mockRestore();
+    }
+  });
+
   // Without this the command is not late, it never happens: an overlay closed in the same tick it
   // opened never pushed an entry, so no reclaim popstate is ever coming.
   it("navigates anyway when no reclaim popstate ever arrives", () => {