fix: the overlaid sidebar steps aside for a drag, and the compact view follows the trigger

Two reports, both real, and neither was about the lock itself.

**A drag out of an overlaid sidebar had nowhere to land.** In a window too narrow to show both columns,
`AdwOverlaySplitView` puts the sidebar *on* the plot — that is what `collapsed` means — so the pointer
stays over the list and never over a drop target: a signal could be dragged but not dropped, which reads
as "dragging does not work". `row_drag_sidebar()` now hides the sidebar on `drag-begin` and restores it on
`drag-end`, and only when collapsed: side by side the plot is already visible, and hiding the list the drag
started in would be startling. The reading begins a drag through the *source* with the state forced
collapsed, the way the sidebar probe forces it:

    pane drag: sidebar hidden for the drag=1 restored after it=1

**The compact view did not follow the trigger switch.** The locked line's first branch reads
`tc.enabled` — with trigger mode off it says `stream (trigger off)` and nothing else — and
`on_trigger_toggled()` never re-synced it, so the line kept saying whichever it had been. One call to
`sync_trigger_summary()` beside the switch sync. The dump's two `panes:` lines were already the test and
now pass it: with a session whose trigger is off, the line as found reads `stream (trigger off)` and the
live one reads the settings, because the exit probe turns the trigger on in between. Both reading `stream`
was the defect.

Verified: the two lines above; `panes: the same line as the probe found it: 'mode: stream (trigger off)'`
against the live `'signal: square | condition: window, rising | level: 0.3 .. 0.6 | mode: normal'`;
`make test-ui` 14 files; zero `Gtk-CRITICAL`. Docs: the `pane drag:` reading and the invariants bullet for
the overlay, and the `panes:` pair's second job — the refresh test — written down so the next reader knows
what both lines reading `stream` means.

src/ui_probe.cpp

@@ -103,6 +103,35 @@ gboolean exit_probe_step3(gpointer user) {
     }
     a->dbg_signal_drag_sources = sources;
   }
+  // A drag out of an *overlaid* sidebar: the sidebar has to step aside or the drop has nowhere to land.
+  // The state is forced the way the sidebar probe forces it -- collapsed is what a window with no room
+  // beside the plot produces -- and the drag is begun through the *source*, so the handler is the one a
+  // real drag reaches.
+  if (a->side_view != nullptr && a->signal_list != nullptr) {
+    AdwOverlaySplitView* split = ADW_OVERLAY_SPLIT_VIEW(a->side_view);
+    GtkWidget* row = gtk_widget_get_first_child(a->signal_list);
+    adw_overlay_split_view_set_collapsed(split, TRUE);
+    adw_overlay_split_view_set_show_sidebar(split, TRUE);
+    if (row != nullptr) {
+      GListModel* controllers = gtk_widget_observe_controllers(row);
+      const guint n = controllers != nullptr ? g_list_model_get_n_items(controllers) : 0;
+      for (guint i = 0; i < n; ++i) {
+        GObject* c = G_OBJECT(g_list_model_get_item(controllers, i));
+        if (GTK_IS_DRAG_SOURCE(c)) {
+          g_signal_emit_by_name(c, "drag-begin", nullptr);
+          a->dbg_drag_hid_sidebar =
+              adw_overlay_split_view_get_show_sidebar(split) == FALSE ? 1 : 0;
+          row_drag_sidebar(*a, false);
+          a->dbg_drag_restored_sidebar =
+              adw_overlay_split_view_get_show_sidebar(split) != FALSE ? 1 : 0;
+        }
+        g_object_unref(c);
+      }
+    }
+    // Left as the window's own width decides, so the readings taken before this are the ones that stand.
+    adw_overlay_split_view_set_collapsed(split, FALSE);
+    adw_overlay_split_view_set_show_sidebar(split, TRUE);
+  }
   // 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