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/skins/7like/app.ts

@@ -16,6 +16,7 @@ import { PanelsService } from '@core/panels.service';
 import { blockNativeContextMenu } from '@core/platform';
 import { RpcService } from '@core/rpc.service';
 import { SettingsService } from '@core/settings.service';
+import { ShortcutsService } from '@core/shortcuts.service';
 import { StatusBar } from './status-bar/status-bar';
 import { TabBar } from './tab-bar/tab-bar';
 import { TitleBar } from './title-bar/title-bar';
@@ -62,6 +63,7 @@ export class App {
   readonly connections = inject(ConnectionsService);
   private readonly transfers = inject(TransfersService);
   private readonly settings = inject(SettingsService);
+  private readonly shortcuts = inject(ShortcutsService);
   private readonly updater = inject(UpdaterService);
 
   /** The connection-manager window is open — this window is modal-blocked. */
@@ -176,26 +178,43 @@ export class App {
     }
   }
 
-  /** Tab (workspace) shortcuts — panel-level keys live on the panels themselves. */
+  /** Window shortcuts — matching lives in ShortcutsService (one keymap for the
+   *  app); this switch only maps ids onto actions. Panel-level keys stay on
+   *  the panels themselves. */
   onWindowKeydown(event: KeyboardEvent): void {
     if (this.managerOpen()) return; // modal-blocked behind the manager
-    const mod = event.metaKey || event.ctrlKey;
-    if (mod && event.key.toLowerCase() === 't') {
-      event.preventDefault();
-      this.panels.newWorkspace();
-    } else if (mod && event.key.toLowerCase() === 'w') {
-      event.preventDefault();
-      this.panels.closeWorkspace(this.panels.activeWorkspaceId());
-    } else if (event.ctrlKey && event.key === 'Tab') {
-      event.preventDefault();
-      this.panels.cycleWorkspace(event.shiftKey ? -1 : 1);
-    } else if (mod && !event.shiftKey && !event.altKey) {
-      // ⌘1–⌘8 jump to that tab, ⌘9 to the last (Ctrl+digit elsewhere), like
-      // Firefox. Matched on event.code so the digit row works on any layout.
-      const digit = /^(?:Digit|Numpad)([1-9])$/.exec(event.code)?.[1];
-      if (!digit) return;
-      event.preventDefault();
-      this.panels.goToWorkspace(digit === '9' ? -1 : Number(digit) - 1);
+    const match = this.shortcuts.resolve(event, 'main');
+    if (!match) return;
+    // scale keys are hostile mid-typing ('-' in a rename prompt must type '-');
+    // the tab shortcuts keep firing there, as they always did
+    if (match.id.startsWith('scale-') && this.shortcuts.isTypingTarget(event)) return;
+    event.preventDefault();
+    switch (match.id) {
+      case 'new-tab':
+        this.panels.newWorkspace();
+        break;
+      case 'close-tab':
+        this.panels.closeWorkspace(this.panels.activeWorkspaceId());
+        break;
+      case 'cycle-tab':
+        this.panels.cycleWorkspace(1);
+        break;
+      case 'cycle-tab-back':
+        this.panels.cycleWorkspace(-1);
+        break;
+      case 'go-to-tab':
+        // ⌘1–⌘8 jump to that tab, ⌘9 to the last, like Firefox
+        this.panels.goToWorkspace(match.digit === 9 ? -1 : match.digit! - 1);
+        break;
+      case 'scale-up':
+        this.settings.setUiScale(this.settings.uiScale() + 0.1);
+        break;
+      case 'scale-down':
+        this.settings.setUiScale(this.settings.uiScale() - 0.1);
+        break;
+      case 'scale-reset':
+        this.settings.setUiScale(1);
+        break;
     }
   }