feat(keys): j/k walk the feed, s finds the search box, g jumps to a module

A feed card cost ~10 Tab stops, so the tenth card sat ~135 Tabs from the top of the page, and the
only keyboard focus ring (a 60% accent outline on the thumbnail) all but vanished on the dark glass.
First slice of the E11 keyboard layer (S4a); Home, Plex and the tables follow in S4b/S4c.

- `lib/listNav`: one window listener over every registered list, walked in document order. `j`/`k`
  step item to item (on into the next list — owner decision D4), the arrows move around a grid, Enter
  clicks the item's own `data-nav-open` element, so it opens exactly like a click. An item root is
  never a Tab stop: it gets `tabindex=-1` only while the keyboard is on it, and keeps it until the next
  item takes it, so the player's focus restore lands back on the card. The first `j` takes the first
  card you can see, not the top of the list.
- `VirtualGrid` takes part with `keyboardNav` (column count + scrolling an unmounted row in);
  `VirtualFeed` turns it on, so the feed, the library and the channel page all have it.
- Keymap: two-step sequences (`g h`) whose pending step belongs to the scope that started it; the
  page-level scopes (`page`, `search`, `list`) are quiet while a layer that owns the keyboard is open,
  enforced in `dispatch`. A test pins the owner's rule that none of them needs a modifier on the
  Hungarian layout.
- `g h/f/c/p/x/n/m/d/s/,` jump to a module this account can reach; `s` focuses the header search box
  and selects the old query; Escape in it hands the keyboard back to the page (Plex's typeahead spends
  its first Escape on its panel).
- Hover popovers are passive layers: an open tooltip still takes Escape first but no longer silences
  the page keys.
- Focus ring (owner decision D2 = B): solid 2px accent around the whole item; the app-wide button/
  link/row ring goes from 60% to solid too. The item keeps a transparent resting outline because the
  video card transitions `all` — without it every `j` flashed a 3px white ring (measured in Chrome).
- Help sheet: the new keys, in a fixed order after the surface's own; a `g` chord only for a reachable
  module; opened over a player or dialog it leaves out the page-level keys and the context-menu key,
  which nothing can reach there (the latter pre-existing since E10).
- CLAUDE.md: a canonical-patterns row for list/grid keys (`useListNav` + `navItemAttrs` +
  `data-nav-open`, not a private arrow-key handler).

frontend/src/lib/layerStack.ts

@@ -16,15 +16,28 @@ import { useEffect, useRef } from "react";
 
 let stack: number[] = [];
 let nextId = 1;
+// Layers that take Escape but do not own the keyboard: an open tooltip or hover card. They sit on the
+// stack for Escape ordering like any other layer, but `anyBlockingLayer` looks past them — otherwise
+// a tooltip that happens to be open under a resting mouse pointer would silence the page's `j`/`k`.
+const passive = new Set<number>();
 
-export function pushLayer(): number {
+export function pushLayer(opts?: { passive?: boolean }): number {
   const id = nextId++;
   stack.push(id);
+  if (opts?.passive) passive.add(id);
   return id;
 }
 
 export function removeLayer(id: number): void {
   stack = stack.filter((x) => x !== id);
+  passive.delete(id);
+}
+
+/** True while a layer that owns the keyboard is open — a modal, a player, a click-opened menu. The
+ *  page-level keys (`s`, the `g` chords, list navigation) stay quiet then: they act on the page
+ *  underneath, which the user cannot see or reach while such a layer is up. */
+export function anyBlockingLayer(): boolean {
+  return stack.some((id) => !passive.has(id));
 }
 
 export function isTopmost(id: number): boolean {
@@ -62,14 +75,17 @@ export function escapeHandled(e: KeyboardEvent): boolean {
 export function useLayer(
   active: boolean,
   onEscape?: () => void,
+  opts?: { passive?: boolean },
 ): { isTopmost: () => boolean; anyAbove: () => boolean } {
   const idRef = useRef<number | null>(null);
   const escRef = useRef(onEscape);
   escRef.current = onEscape;
+  const passiveRef = useRef(!!opts?.passive);
+  passiveRef.current = !!opts?.passive;
 
   useEffect(() => {
     if (!active) return;
-    const id = pushLayer();
+    const id = pushLayer({ passive: passiveRef.current });
     idRef.current = id;
     let onKey: ((e: KeyboardEvent) => void) | undefined;
     if (escRef.current) {