feat(playlists): hybrid table over the drag list, and guard its destructive paths

The column sort and the filters are a VIEW; the playlist's stored order only
changes when the user presses "Save this order", which still goes through the
undoable path. Picking a sort used to write straight to the server, so merely
looking at the list by title rewrote the playlist and marked a YouTube-linked
mirror dirty.

The table:
- playlistColumns.tsx holds the column defs; the body renders them as table rows
  and fills the grip cell itself, since the handle needs the row's sortable
  listeners that a render closure can't reach.
- The # column shows the STORED position, so a view-sort never renumbers the
  playlist under the reader.
- Saving is withheld while a filter is active (it would drop the hidden items),
  and drag is disabled under any view, with the reason spelled out rather than
  silently doing nothing.
- applyView/sameOrder live in lib/playlistView.ts with tests: the sort and the
  channel grouping compose, and getting that wrong produces a plausible order
  that the save button would then persist.
- dnd-kit KeyboardSensor: the grip was focusable and called itself "reorder",
  but only a pointer could move it.

The guards:
- Delete is ONE dialog with every outcome. It was two chained confirms where the
  second one's Cancel/Escape/backdrop meant "delete here only" — dismissing the
  dialog deleted the playlist. ConfirmProvider gained useChoice() for it.
- ConfirmProvider focuses Cancel when an offered action is destructive; the
  confirm button took autoFocus unconditionally, so a stray Enter on an open
  dialog ran "Delete user" or "Clear audit log".
- Removing an item asks first, and rebases the undo history instead of throwing
  it away: useUndoable.rebase maps every snapshot, so the reorder history stays
  valid for the remaining items.
- A failed detail query showed "Loading…" forever; it now says so and offers a
  retry. Rename and reorder failures are surfaced instead of swallowed (reorder
  was a bare .then(), which also produced an unhandled rejection).
- Local reorder/remove no longer require YouTube write scope.
- playlistName() replaces the watch-later localizer copied into three files.

frontend/src/lib/useUndoable.ts

@@ -15,6 +15,7 @@ export interface Undoable<T> {
   value: T;
   set: (next: T) => void;
   reset: (value: T) => void;
+  rebase: (map: (value: T) => T) => void;
   undo: () => void;
   redo: () => void;
   canUndo: boolean;
@@ -77,11 +78,27 @@ export function useUndoable<T>(
     force();
   }, []);
 
+  // Apply the same transformation to EVERY snapshot — past, present and future — and keep the
+  // history. For changes that are outside the undoable dimension but invalidate the snapshots:
+  // removing a playlist item is not itself undoable, yet dropping it from each stored order keeps
+  // the user's reorder history valid and usable instead of throwing it away (which is what a
+  // `reset` does). No `onApply`: the caller is already persisting the change by its own route.
+  const rebase = useCallback((map: (value: T) => T) => {
+    const s = ref.current;
+    ref.current = {
+      past: s.past.map(map),
+      present: map(s.present),
+      future: s.future.map(map),
+    };
+    force();
+  }, []);
+
   const h = ref.current;
   return {
     value: h.present,
     set,
     reset,
+    rebase,
     undo,
     redo,
     canUndo: h.past.length > 0,