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_signals.cpp

@@ -166,7 +166,7 @@ int math_index_for_signal(App& app, const std::string& name) {
 /// The `MATH` boundary in the one channel list, carrying the `+` that creates a channel. Not
 /// selectable and not activatable: it is a heading, and a heading that highlights under the
 /// pointer reads as a row you can plot.
-GtkWidget* make_math_divider(App& app) {
+GtkWidget* make_math_divider(App& app, bool with_add) {
   GtkWidget* row = gtk_list_box_row_new();
   gtk_list_box_row_set_selectable(GTK_LIST_BOX_ROW(row), FALSE);
   gtk_list_box_row_set_activatable(GTK_LIST_BOX_ROW(row), FALSE);
@@ -180,11 +180,16 @@ GtkWidget* make_math_divider(App& app) {
   gtk_widget_set_halign(label, GTK_ALIGN_START);
   gtk_widget_set_hexpand(label, TRUE);
   gtk_box_append(GTK_BOX(box), label);
-  GtkWidget* add = gtk_button_new_from_icon_name("list-add-symbolic");
-  gtk_widget_add_css_class(add, "flat");
-  gtk_widget_set_tooltip_text(add, "add a math channel");
-  g_signal_connect(add, "clicked", G_CALLBACK(on_math_add_clicked), &app);
-  gtk_box_append(GTK_BOX(box), add);
+  // Locked: the heading stays, because the list it divides is the one being read, but the `+` that
+  // creates a channel does not. A `+` on a locked list is a button that opens the editor the lock
+  // exists to keep shut.
+  if (with_add) {
+    GtkWidget* add = gtk_button_new_from_icon_name("list-add-symbolic");
+    gtk_widget_add_css_class(add, "flat");
+    gtk_widget_set_tooltip_text(add, "add a math channel");
+    g_signal_connect(add, "clicked", G_CALLBACK(on_math_add_clicked), &app);
+    gtk_box_append(GTK_BOX(box), add);
+  }
   gtk_list_box_row_set_child(GTK_LIST_BOX_ROW(row), box);
   return row;
 }
@@ -278,6 +283,9 @@ void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals) {
   std::size_t plain = 0;
   for (std::size_t i = 0; i < signals.size(); ++i) {
     if (ScopeModel::is_time_signal(signals, i)) continue;  // the time base is not plottable
+    // Locked: a row per signal that is *on*, which is the list a user reads rather than the list they
+    // configure. Turning one on is what the pane's [edit] button is for.
+    if (app.signals_locked && !app.model->signal_enabled(i)) continue;
     const std::string base = layer_base_name(signals[i].name);
     bool seen = false;
     for (std::size_t j = 0; j < i && !seen; ++j) {
@@ -293,7 +301,7 @@ void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals) {
     // `+` that creates the first one.
     if (sig.math && !math_divider_done) {
       math_divider_done = true;
-      gtk_list_box_append(GTK_LIST_BOX(list), make_math_divider(app));
+      gtk_list_box_append(GTK_LIST_BOX(list), make_math_divider(app, !app.signals_locked));
     }
     if (!sig.math) ++plain;
     GtkWidget* row = gtk_list_box_row_new();
@@ -309,7 +317,7 @@ void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals) {
         chip, !app.model->signal_enabled(i) ? "not acquired"
               : plotted ? "the colour this signal is plotted in -- click to change it"
                         : "on no plot, so there is no trace to colour");
-    if (plotted) {
+    if (plotted && !app.signals_locked) {
       // A gesture on the label rather than a `GtkButton` around it: a button brings its own
       // padding, and padding on this row is what made the list twice as tall once already (see
       // this function's note). The chip also has to stay exactly one disc wide, or the names
@@ -343,7 +351,9 @@ void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals) {
     gtk_widget_set_visible(enable, sig.math || app.waveform_name.empty());
     g_object_set_data(G_OBJECT(enable), "udpscope-signal", GSIZE_TO_POINTER(i));
     g_signal_connect(enable, "notify::active", G_CALLBACK(on_signal_switch), &app);
-    gtk_box_append(GTK_BOX(box), enable);
+    // Locked: the switch decides what is acquired, so it is a configuration control and it goes with
+    // the rest of them.
+    if (!app.signals_locked) gtk_box_append(GTK_BOX(box), enable);
 
     GtkWidget* name = gtk_label_new(sig.name.c_str());
     gtk_widget_set_hexpand(name, true);
@@ -435,7 +445,9 @@ void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals) {
     gtk_menu_button_set_popover(GTK_MENU_BUTTON(more), popover);
     gtk_widget_add_css_class(more, "flat");
     gtk_widget_set_tooltip_text(more, "information and calibration");
-    gtk_box_append(GTK_BOX(box), more);
+    // Locked: the menu holds calibration, deletion and a rename, which are exactly what this mode is
+    // not for. The popover is left unattached, so nothing can reach it.
+    if (!app.signals_locked) gtk_box_append(GTK_BOX(box), more);
 
     gtk_list_box_row_set_child(GTK_LIST_BOX_ROW(row), box);
 
@@ -451,7 +463,9 @@ void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals) {
   }
   // Appended when there are no math channels at all: the `+` is the only way to create the first
   // one, so it cannot be conditional on one already existing.
-  if (!math_divider_done) gtk_list_box_append(GTK_LIST_BOX(list), make_math_divider(app));
+  if (!math_divider_done) {
+    gtk_list_box_append(GTK_LIST_BOX(list), make_math_divider(app, !app.signals_locked));
+  }
   app.dbg_signal_plain = plain;
   app.dbg_signal_rows = 0;
   for (GtkWidget* c = gtk_widget_get_first_child(list); c != nullptr;
@@ -567,6 +581,10 @@ GtkWidget* build_signal_panel(App& app) {
   GtkBuilder* ui = ui_load(app, "/org/udpscope/ui/signals-panel.ui");
   GtkWidget* box = GTK_WIDGET(gtk_builder_get_object(ui, "signal_panel"));
   app.signal_list = GTK_WIDGET(gtk_builder_get_object(ui, "signal_list"));
+  app.signals_edit = GTK_WIDGET(gtk_builder_get_object(ui, "signals_edit"));
+  if (app.signals_edit != nullptr) {
+    g_signal_connect(app.signals_edit, "clicked", G_CALLBACK(on_pane_edit_clicked), &app);
+  }
   if (box == nullptr || app.signal_list == nullptr) {
     // A missing id is a mistake in the `.ui`: the panel comes up empty rather than taking the window with
     // it, and `[udpscope] signals panel:` reads the difference.