feat: locked panes for a returning user, and the trigger is persisted

Two panes, two modes. **Locked** is what a returning user gets: the trigger pane shows one line saying
what it is set to, the signal list shows only the signals that are on, and neither offers a control that
changes the configuration — each heading has an `[edit]` button (the Adwaita `emblem-system-symbolic`,
swapping to `emblem-ok-symbolic` in configuration mode) that flips its pane. A **first run** — no session
file for that source — never reaches `apply_layout()` and comes up in configuration mode, because
configuring the host is what a first run is for. The mode is a mode and not a setting, so it is
deliberately not persisted.

The locked signal list drops the rows of every signal that is off, which is the whole of "show active
signals": the list already filters on nothing, so the lock is one `continue`. With the rows go the acquire
tick, the overflow menu (Information, Calibrate…, Delete, rename) and the `MATH` divider's `+` — and the
colour chip stops being clickable, because choosing a colour is configuration too. Dragging a signal onto
a plot stays: that is which view shows what, not what the scope is set up to do.

**The trigger is persisted, settings and state both** — the settings *even while it is off*, which is the
point: a trigger configured once and switched off is still the trigger you come back to. `LayoutState`
gains fifteen flat `trigger_*` keys; the channel is stored by *name* (every rebuild renumbers the
channels, the model's own rule) and the two enumerations as **the words the panel's dropdowns show**,
because an index ties the file to a declaration order — the lesson `math_op_at()` already carries. The
words are shared with the panel now (`trigger_type_text()` and friends build the dropdown arrays), so the
two cannot drift.

Two ordering traps, both found by running it:

- **The channel name resolves twice over.** `rebuild_trigger_signals()` picks up
  `App::pending_trigger_channel` when the stream arrives *after* the load, and `apply_trigger_layout()`
  resolves it itself when the channels are already there — without the second path the name stayed
  pending past the one rebuild that would have used it, and the trigger silently sat on channel 0
  (`summary='pulse width · sine …'` where the session said `square`).
- **The trigger's state is applied by pressing the control, not by setting a flag**: the toggle is set
  *outside* the `updating_panels` window `apply_layout()` uses, because a toggle set inside it emits
  `toggled` into a handler that returns at once and nothing would happen — no arming, no events button,
  no sensitivity.

Verified, in both modes and both directions:

    panes: trigger=locked signals=locked body_visible=0 summary='window · square · 0.3…0.6 · 20 % pre'
    panes: trigger=config signals=config body_visible=1 summary=''
    signals panel: labels=2 list=1 rows=7 signals=2 math=4 divider=1

The locked trigger pane is 42 px tall against 580 unlocked. A hand-written session round-trips: every
value it named came back in the panel's own controls, `trigger=1/1` (the state arrived and the pane's
switch followed it), and the file the app wrote back carried all fifteen keys with the untouched ones at
their defaults. `[side-tab-probe] … advanced=4` on its documented recipe; `make test-ui` 14 files; zero
`Gtk-CRITICAL` and no missing icon.

Docs: the `panes:` reading with what each field means, the corrected `labels=` note (the panel's frame is
counted above the list now, because the heading sits in a heading row), the invariants for both the
persistence and the lock, the README's deviation note, and the removal of its claim that the trigger has
never been persisted — it is now, and the locked view is built from exactly that.

src/ui_app.hpp

@@ -258,6 +258,26 @@ struct App {
   /// True while `sync_panel_switches()` is writing the switches: setting a `GtkSwitch` emits its own
   /// `notify::active`, and without this the program's own write would come back as a click.
   bool panel_switch_sync = false;
+  /// The channel a session's trigger names, until `rebuild_trigger_signals()` can resolve it: the
+  /// file stores a *name* and the trigger needs an index into the acquired channels, which do not
+  /// exist until the stream has been described. Empty means "nothing pending".
+  std::string pending_trigger_channel;
+  /// The two panes' modes. *Locked* is the one a returning user gets: the trigger pane shows a line
+  /// that says what it is set to, the signal list shows only the signals that are on, and neither
+  /// offers a control that changes the configuration. A first run -- no session file for this source
+  /// -- starts in configuration mode, because that is what a first run is for. The flags last for the
+  /// session: a lock is a mode, not a setting, so it is not persisted.
+  bool trigger_locked = false;
+  bool signals_locked = false;
+  GtkWidget* trigger_summary = nullptr;
+  GtkWidget* trigger_edit = nullptr;
+  GtkWidget* signals_edit = nullptr;
+  int dbg_trigger_locked = -1;
+  int dbg_signals_locked = -1;
+  int dbg_trigger_body_visible = -1;
+  /// The compact line the locked trigger pane shows. It is the pane's whole content in that mode, so it
+  /// is read rather than assumed: empty here is a locked pane showing nothing at all.
+  std::string dbg_trigger_summary;
   /// The cursors pane: listing what the instruments read -- T0/T1/dT always, per row an Y1/Y2/dY
   /// where rulers are up, and in `mix` mode the value each cursor crosses each trace at.
   GtkWidget* cursors_mode_drop = nullptr;
@@ -1279,7 +1299,7 @@ void on_signal_color_chosen(GObject* source, GAsyncResult* res, gpointer user);
 void open_signal_color(App& app, std::size_t signal);
 void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals);
 /// The `MATH` divider row in the one channel list, and the `+` it carries.
-GtkWidget* make_math_divider(App& app);
+GtkWidget* make_math_divider(App& app, bool with_add);
 void on_math_add_clicked(GtkButton* button, gpointer user);
 /// The index in `App::math` of the channel a synthetic signal is named after, or `-1`.
 int math_index_for_signal(App& app, const std::string& name);
@@ -1413,6 +1433,25 @@ void select_side_tab(App& app, const char* name);
 /// Reads each pane's own switch back off the header bar's button, and the other way round: the two are
 /// one control in two places, and `panel_switch_sync` keeps the write from looking like a click.
 void sync_panel_switches(App& app);
+/// The trigger's four enumerations as words: the panel's dropdown labels and the session file's
+/// vocabulary, in one place so the two cannot drift.
+const char* trigger_type_text(TriggerType t);
+TriggerType trigger_type_from_text(const std::string& s);
+const char* trigger_edge_text(TriggerEdge e);
+TriggerEdge trigger_edge_from_text(const std::string& s);
+const char* width_cmp_text(WidthCmp c);
+WidthCmp width_cmp_from_text(const std::string& s);
+const char* trigger_mode_text(TriggerMode m);
+TriggerMode trigger_mode_from_text(const std::string& s);
+/// The panel's controls from the model, and the session's trigger into both.
+void write_trigger_widgets(App& app);
+/// The compact line the trigger pane shows while it is locked, and the lock itself: the panes'
+/// bodies, their [edit] buttons and the signal list's rows all follow from `trigger_locked` and
+/// `signals_locked`.
+void sync_trigger_summary(App& app);
+void apply_pane_lock(App& app);
+void on_pane_edit_clicked(GtkButton* button, gpointer user);
+void apply_trigger_layout(App& app, const LayoutState::Trigger& t);
 void on_panel_switch_toggled(GObject* obj, GParamSpec*, gpointer user);
 void update_side_visibility(App& app);
 void on_sidebar_toggled(GtkToggleButton* button, gpointer user);