scope windows: their own layout editor, and the same shortcuts

A detached window is a view with an arrangement of its own -- and there was no way to change it:
the layout editor was the main window's, and a second window's rows could not be added or removed.

Every scope window now carries its own editor: `L` (or the grid toggle in its corner, revealed by
the same proximity rule as the attach button) shows the main editor's `+` / `×` / Done controls,
and they act on **that window's** row set (`set_scope_layout_editing()`, every button tagged with
its window), so a window holds as many figures as the user gives it and the two editors cannot
move each other's rows. Nothing a scope window arranges is written to the main window's session:
the windows themselves are not persisted.

The keyboard: each scope window gets a `GtkEventControllerKey` running the application's one
accelerator table -- `L` acts on the window the key arrived in, every other action reaches the
application through `run_app_action()`. The plot's own keys ('f', the arrows, Escape) already
worked there, through its plot controller.

The window struct now always builds its overlay (the corner controls' host); the attach button
stays detached-only, and both corner toggles step aside while the editor is up (Done is the way
out).

Probe: `[scope-probe] layout buttons=3 rows=1->2` -- the toggle builds 2*rows+1 buttons and a
boundary `+` adds a row. `L` in a real scope window verified by OCR ("Done" appears, the row's
`×` at its left). Docs: README, the Mallard layout page, the probe readings, and the layout
invariant (a view's arrangement is the view's).

docs/claude/invariants-plot-and-layout.md

@@ -380,3 +380,12 @@ Part of [CLAUDE.md](../../CLAUDE.md). These are rules that cost a defect to lear
   figure row carries **no** toggle (and no menu entry): there is nothing to enlarge *to*, and a
   visible no-op is worse than none. The button reappears while a row *is* maximized, because
   there it is the way back.
+
+- **A view's arrangement is the view's, editor included.** A scope window holds its own figure
+  rows and edits them with its own `+`/`×`/Done set (`set_scope_layout_editing()`,
+  `rebuild_scope_layout_editor()`, `sync_scope_layout_editor()`): the buttons are tagged with the
+  window and the handlers act on *that* window's row set, so the two editors cannot move each
+  other's figures. `L` acts on the window the key arrived in (a `GtkEventControllerKey` per
+  window; every other accelerator reaches the application through `run_app_action()`), and a
+  pinned layout change is **not** written to the main window's session — the windows themselves
+  are not persisted.

docs/claude/probe-readings.md

@@ -1500,6 +1500,10 @@ a defect in the copy. Measured output:
   is the defect this exists for: `pin_event_window()` takes **spans**, and passing it a range's
   signed `min` turned the window inside out, so a scope in Held or Paused mode drew no trace and no
   x labels at all.
+- `layout buttons=3 rows=1->2` is the window's **own layout editor**: the toggle builds
+  `2 × rows + 1` buttons (a `×` per row, a `+` per boundary, Done is not counted) for one figure,
+  and emitting the first boundary `+` adds a row. A wrong count is a button set built for the main
+  window's rows; `rows` unchanged is a handler writing the wrong row set.
 - `rclick=1` is the scope window's **own right-click menu** being wired (one click gesture with
   button 3 on its GL area, beside the drop target): the menu's actions act on that window's row
   set.