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_app.hpp

@@ -261,6 +261,9 @@ 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;
+  /// True while a drag has the overlaid sidebar hidden: what it was showing before, so `drag-end` puts it
+  /// back rather than guessing.
+  bool sidebar_hidden_for_drag = 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".
@@ -822,6 +825,9 @@ struct App {
   int dbg_signal_rows = 0;
   /// How many rows of the list carry a `GtkDragSource`: `rows - 1`, the divider not being draggable.
   int dbg_signal_drag_sources = -1;
+  /// The drag-with-an-overlaid-sidebar pair: the sidebar hid for the drag, and came back after it.
+  int dbg_drag_hid_sidebar = -1;
+  int dbg_drag_restored_sidebar = -1;
   std::size_t dbg_signal_plain = 0;
   int dbg_side_column_after_hide = 1;
   std::string dbg_mode_triggered;
@@ -1462,6 +1468,10 @@ 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);
+/// Hides the sidebar for the length of a drag when it is *overlaid*, and puts it back after. With the
+/// split view collapsed the sidebar covers the plot, so a drag that starts in the signal list has nowhere
+/// to land: the pointer is over the sidebar, not over a drop target.
+void row_drag_sidebar(App& app, bool dragging);
 /// 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`.