ui: each pane carries its own switch, the same one the header bar has

The trigger pane and the cursors pane now have a `GtkSwitch` in their heading, and it is *one control in
two places* with the header bar's button: both run the same action (`run_app_action()`), and
`sync_panel_switches()` re-reads each pair from the toolbar's state after any change, so clicking either
end moves both. A pane whose feature is off is disabled, which is exactly the state you need the switch
in, so it belongs *in* the pane rather than only in the toolbar.

Three things it needed:

- **The sensitive target moved to the pane's body.** A control inside an insensitive parent cannot be
  clicked, so a switch that greyed out with its own pane could never turn it back on. `on_trigger_toggled`
  and `on_cursors_toggled` now disable `trigger_body` / `cursors_body`, and so does the startup default;
  the headings, with their switches, stay live.
- **The trigger's heading moved out of `trigger-panel.ui`** and is built in `build_trigger_panel()`,
  which returns the heading row and the panel together. It has to be a sibling of the body for the switch
  to stay usable, and keeping it in the file would have meant the file owning a widget the code must
  arrange. The file's own panel is unchanged otherwise, so the `[trigger panel:]` counts still read.
- **A guard on the sync.** Setting a `GtkSwitch` emits `notify::active` for a programmatic write just as
  it does for a click, so without `App::panel_switch_sync` the program's own write would come back as a
  click and flip the feature again.

Readings, both directions in one line:

    trigger panel sensitive before the probe toggled it: 0; … ; pane switches live while their panes are off=1
    panel switches: trigger=1/1 cursors=1/1 drove_toolbar=1  (pane switch / header bar button)

`pane switches live …=1` is the design's point and is read before anything turns either pane on; `0` would
be a switch drawn, greyed and useless. The trigger pair is moved from the *toolbar* end and the cursors
pair from the *pane* end, so the line carries both halves of the sync, and `drove_toolbar=1` is the pane's
own switch having turned the cursors on with the button following. `trigger panel sensitive …=0` is the
body, not the panel.

Verified: the two lines above; `[side-tab-probe] … advanced=4`; `make test-ui` 14 files; zero
`Gtk-CRITICAL` and no missing icon. Docs: the new reading in `probe-readings.md` with what a `0` means,
the invariants bullet for the one-control-in-two-places rule and its two traps, the sidebar bullet's
sensitive target, and the README note on why the switch is in the pane.

src/ui_probe.cpp

@@ -85,6 +85,28 @@ gboolean exit_probe_step3(gpointer user) {
     a->dbg_switcher_w = gtk_widget_get_width(a->side_switcher);
     a->dbg_switcher_h = gtk_widget_get_height(a->side_switcher);
   }
+  // The panes' own switches, and *both* directions of the sync: the header bar's trigger button is
+  // flipped here and the pane's switch has to follow, then the cursors' switch is driven from the
+  // pane and the button is what has to follow. Both are read back after the fact, so the two pairs in
+  // the dump are the claim: they agree, having been moved from opposite ends.
+  if (a->trigger_toggle != nullptr) {
+    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a->trigger_toggle), TRUE);
+  }
+  a->dbg_panel_switch_trigger =
+      a->trigger_switch != nullptr && gtk_switch_get_active(GTK_SWITCH(a->trigger_switch)) ? 1 : 0;
+  a->dbg_toolbar_switch_trigger =
+      a->trigger_toggle != nullptr &&
+              gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(a->trigger_toggle))
+          ? 1 : 0;
+  if (a->cursors_switch != nullptr) {
+    gtk_switch_set_active(GTK_SWITCH(a->cursors_switch), TRUE);
+    a->dbg_panel_switch_cursors = gtk_switch_get_active(GTK_SWITCH(a->cursors_switch)) ? 1 : 0;
+    a->dbg_toolbar_switch_cursors =
+        a->cursors_toggle != nullptr &&
+                gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(a->cursors_toggle))
+            ? 1 : 0;
+    a->dbg_panel_drove_toolbar = a->dbg_toolbar_switch_cursors;
+  }
   for (GtkWidget* pill = a->side_switcher != nullptr ? gtk_widget_get_first_child(a->side_switcher)
                                                     : nullptr;
        pill != nullptr; pill = gtk_widget_get_next_sibling(pill)) {
@@ -116,7 +138,7 @@ gboolean exit_probe_step3(gpointer user) {
   const int on_signals = page != nullptr && std::strcmp(page, "signals") == 0 ? 1 : 0;
   a->dbg_signal_page_current =
       on_signals && gtk_widget_get_first_child(a->signal_list) != nullptr ? 1 : 0;
-  a->dbg_trigger_sensitive = on_signals && gtk_widget_get_sensitive(a->trigger_panel) ? 1 : 0;
+  a->dbg_trigger_sensitive = on_signals && gtk_widget_get_sensitive(a->trigger_body) ? 1 : 0;
   // `gtk_widget_get_visible` on the sidebar's GtkBox is always 1: AdwOverlaySplitView hides its
   // sidebar child via `gtk_widget_set_child_visible()`, not `gtk_widget_set_visible()`. The useful
   // reading is whether the split view is currently showing the sidebar panel.
@@ -2299,7 +2321,11 @@ gboolean export_probe(gpointer user) {
 gboolean exit_probe_step1(gpointer user) {
   App* a = static_cast<App*>(user);
   // Record the panel states before the toggles are exercised.
-  a->dbg_trigger_sensitive_default = gtk_widget_get_sensitive(a->trigger_panel) ? 1 : 0;
+  a->dbg_trigger_sensitive_default = gtk_widget_get_sensitive(a->trigger_body) ? 1 : 0;
+  a->dbg_panel_switch_live =
+      a->trigger_switch != nullptr && gtk_widget_get_sensitive(a->trigger_switch) &&
+              a->cursors_switch != nullptr && gtk_widget_get_sensitive(a->cursors_switch)
+          ? 1 : 0;
   if (a->trigger_toggle != nullptr) {
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a->trigger_toggle), TRUE);
   }
@@ -2342,7 +2368,7 @@ void cursors_probe_report(App& a, const char* what) {
                "[cursors-probe] %-14s mode=%-10s on=%d pane_sensitive=%d t0=%.6f t1=%.6f dt=%.6f "
                "T=[%s] lines=%d marks=%d [%s]\n",
                what, kModes[mode], a.rows->cursors_visible() ? 1 : 0,
-               a.cursors_panel != nullptr && gtk_widget_get_sensitive(a.cursors_panel) ? 1 : 0,
+               a.cursors_body != nullptr && gtk_widget_get_sensitive(a.cursors_body) ? 1 : 0,
                a.rows->cursor_a_x(), a.rows->cursor_b_x(),
                a.rows->cursor_b_x() - a.rows->cursor_a_x(), t_text.c_str(), n,
                a.rows->crossings_visible(), lines.c_str());