Scale stage 3: shortcuts service + Ctrl/Cmd +/-/0 for the scale

Groundwork for the vim-style bindings planned next: the app previously had NO
keyboard abstraction — `event.metaKey || event.ctrlKey` copy-pasted inline in
six places, no typing-target guard anywhere, every window root matching keys
by hand.

New @core/shortcuts.service.ts owns:
- isMod() (also accepts MouseEvent — Mod+click toggle-select uses the same
  rule) and isTypingTarget();
- ONE declarative keymap: resolve(event, scope) -> ShortcutId | null, scoped
  main / editor / manager. Layout rules are encoded once: digits, +/- and
  Alt-letter chords match on event.code (AZERTY digit rows, layouts where '+'
  needs Shift, macOS Option-Z producing Ω); plain letter chords match on
  event.key so they follow the user's layout.

Both app.ts, both editor-window.ts and both connection-manager.ts now resolve
through the service and switch on ids — behaviour-preserving for every
existing shortcut, including the deliberate quirks (Ctrl+Tab never meta
because Cmd-Tab is the macOS app switcher; Cmd+9 = last tab; editor Mod+W is
the Windows/Linux arm, macOS routes via the app menu). Escape and Tab stay
component-local on purpose: their meaning is per-window state (find bar open?
close prompt up? caret in the textarea?), not a global binding. The file
panels keep their contextual key state machine but delegate modifier tests.

On top of the table: Ctrl/Cmd +/-/0 steps/resets the interface scale in every
window kind, all three previously unclaimed. isTypingTarget is applied
per-shortcut, not globally in resolve(): the scale keys must not fire while
typing ('-' in a rename prompt must type '-'), but the editor WANTS Mod+S
mid-typing and the tab shortcuts keep their existing reach.

Docs: architecture.md's density prose now describes the uiScale lever;
gotchas.md gains the scale section — the disassembly evidence that native
page zoom is an empty stub on Linux (so nobody tries it again), the
everything-must-be-rem rule, the skinfix-outranks-variants trap the harness
caught (48px close button silently 29px), and the px-mirrors-in-TS class of
bug with the remPx() remedy.

Verified: tsc + build clean; live boot with the user's real legacy settings
file migrates textSize:large -> uiScale 1.2 and renders scaled. Not verified
here (needs interaction): the stepper clicks and the shortcut keys themselves.

Co-Authored-By: Claude <noreply@anthropic.com>

ui/src/app/core/shortcuts.service.ts

@@ -0,0 +1,111 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * Every window-level shortcut the app answers to, by name. Components switch
+ * on these ids instead of key-matching inline, so the whole keymap is ONE
+ * table — the precondition for the vim-style bindings planned next, which
+ * will need a mode/leader state machine wrapped around exactly this point.
+ */
+export type ShortcutId =
+  // main window (workspace/tab management)
+  | 'new-tab'
+  | 'close-tab'
+  | 'cycle-tab'
+  | 'cycle-tab-back'
+  | 'go-to-tab' // 1-9; the digit rides in ShortcutMatch.digit
+  // editor window
+  | 'save'
+  | 'find'
+  | 'close-window'
+  | 'toggle-wrap'
+  // any window
+  | 'scale-up'
+  | 'scale-down'
+  | 'scale-reset';
+
+export interface ShortcutMatch {
+  id: ShortcutId;
+  /** Only for go-to-tab: the digit pressed, 1–9. */
+  digit?: number;
+}
+
+/** Which keymap a window consults. 'manager' answers only to the any-window
+ *  shortcuts (scale). Escape/Tab stay component-local: their meaning is
+ *  contextual state (find bar open? close prompt up? which pane?), not a
+ *  global binding. */
+export type ShortcutScope = 'main' | 'editor' | 'manager';
+
+/**
+ * The keyboard layer: modifier helpers + one declarative keymap.
+ *
+ * House rules encoded here rather than re-derived per component (they were
+ * previously copy-pasted inline in six places, drifting apart):
+ * - `mod` is metaKey OR ctrlKey — ⌘ on macOS, Ctrl elsewhere. The keyboard
+ *   does not change with the window chrome (platform.ts says the same about
+ *   MOD_LABEL).
+ * - Layout-dependent keys match on `event.code`, not `event.key`: digits
+ *   (AZERTY's digit row shifts), +/- (key varies wildly across layouts), and
+ *   letter chords with Alt (macOS Option produces Ω for ⌥Z). Plain letter
+ *   chords match on `key` so they follow the user's layout.
+ * - isTypingTarget guards shortcuts that would be hostile mid-typing. It is
+ *   deliberately NOT applied inside resolve(): the existing bindings rely on
+ *   the path bar's stopPropagation and the editor WANTS Mod+S while typing.
+ *   Callers opt in per shortcut (the scale keys do).
+ */
+@Injectable({ providedIn: 'root' })
+export class ShortcutsService {
+  /** The platform command modifier: ⌘ on macOS, Ctrl elsewhere. Mouse events
+   *  qualify too — Mod+click toggle-select in the panels uses the same rule. */
+  isMod(event: KeyboardEvent | MouseEvent): boolean {
+    return event.metaKey || event.ctrlKey;
+  }
+
+  /** True when the event originates from something the user types into. */
+  isTypingTarget(event: KeyboardEvent): boolean {
+    const target = event.target as HTMLElement | null;
+    return !!target?.closest('input, textarea, select, [contenteditable="true"]');
+  }
+
+  /**
+   * Match an event against the scope's keymap. Returns null for anything the
+   * table does not claim — callers must then leave the event alone.
+   */
+  resolve(event: KeyboardEvent, scope: ShortcutScope): ShortcutMatch | null {
+    const mod = this.isMod(event);
+    const key = event.key.toLowerCase();
+
+    // ---- any window: interface scale ----
+    // event.code, not key: '+' needs Shift on many layouts and '-' moves
+    // around; the physical Equal/Minus keys (and the numpad pair) are stable.
+    if (mod && !event.altKey) {
+      if (event.code === 'Equal' || event.code === 'NumpadAdd') return { id: 'scale-up' };
+      if (event.code === 'Minus' || event.code === 'NumpadSubtract') return { id: 'scale-down' };
+      if (event.code === 'Digit0' || event.code === 'Numpad0') return { id: 'scale-reset' };
+    }
+
+    if (scope === 'manager') return null; // any-window shortcuts only
+
+    if (scope === 'main') {
+      if (mod && key === 't') return { id: 'new-tab' };
+      if (mod && key === 'w') return { id: 'close-tab' };
+      // ctrlKey only, never meta: ⌘Tab is the macOS app switcher
+      if (event.ctrlKey && event.key === 'Tab') {
+        return { id: event.shiftKey ? 'cycle-tab-back' : 'cycle-tab' };
+      }
+      if (mod && !event.shiftKey && !event.altKey) {
+        const digit = /^(?:Digit|Numpad)([1-9])$/.exec(event.code)?.[1];
+        if (digit) return { id: 'go-to-tab', digit: Number(digit) };
+      }
+      return null;
+    }
+
+    // scope === 'editor'
+    if (mod && key === 's') return { id: 'save' };
+    if (mod && key === 'f') return { id: 'find' };
+    // on macOS the app menu intercepts ⌘W before this ever fires; this arm is
+    // the Windows/Linux path
+    if (mod && key === 'w') return { id: 'close-window' };
+    if (event.altKey && event.code === 'KeyZ') return { id: 'toggle-wrap' };
+    return null;
+  }
+}