scope windows take drops, and the signal page lists them

The second windows were read-only by accident: nothing accepted a drop on them, and the
signal page's *Plot on* buttons knew only the main window's rows.

- **Drop target per scope window**: the same string payload a badge drags (the signal index),
  handled by `on_scope_drop_channel()` -- the target carries its own window, the row is that
  window's cell under the pointer, and `assign_signal_to_scope()` lands the signal in the
  window's own row set (enabling an unacquired signal first, exactly as the main drop does).
  The rebuild and the area's re-point are the window's next frame in the tick: a drop arrives
  from inside the very widget it rearranges, and a synchronous rebuild would reset the drag
  controller under it.
- **Plot on, per window**: the signal page carries one named group per scope window ("In
  \"plot 2\""), one button per plot of that window, sensitive on that window's own rows. A
  window closing refreshes the pages in its destroy handler, before the deferred delete could
  dangle a button's scope pointer.
- Probe: `[scope-probe]` drops through the wired handler (`drop=1 slot1='square'`) and counts
  the page's groups (`page_groups=2`); the section documents that it must not run with
  `UDPSCOPE_ENABLE_ALL_MS` -- the enable-all probe's second leg clears the front plot, which
  is the slot this probe copies. README, help and the layout invariant follow.

src/ui_app.hpp

@@ -215,6 +215,12 @@ struct App {
     GtkWindow* window = nullptr;
     plot::gtk4::PlotArea* area = nullptr;
     GtkWidget* widget = nullptr;
+    /// The window's short name, the one the signal page's *Plot on* groups carry ("plot 2" for a
+    /// copy, "scope 3" for an empty one): a button must say which window it plots into.
+    std::string name;
+    /// The drop target wired onto `widget`: the handler reads the *window* off it (each window's
+    /// target names its own scope), and the probe calls the handler with it directly.
+    GtkDropTarget* drop = nullptr;
     /// The area's initial plot, owned here: `PlotArea::create()` wants a `Plot&` that
     /// outlives the widget, and sharing the main window's placeholder would hand two areas
     /// one plot the moment the figure mode is ever left.
@@ -222,6 +228,8 @@ struct App {
     std::unique_ptr<RowSet> rows;
   };
   std::vector<std::unique_ptr<ScopeWindow>> scopes;
+  /// Every empty scope window is numbered from this, so two of them never share a name.
+  int scope_seq = 0;
 
   /// On while the layout editor is up. Nothing else about the plot changes: the editor is
   /// a set of overlay buttons, not a mode the figure knows about.
@@ -2038,6 +2046,13 @@ void row_menu_fill(RowMenuState& st);
 GtkWidget* open_row_menu(App& app, int row, double x, double y, GtkWidget* parent, bool autohide = true);
 void on_right_click(GtkGestureClick* gesture, int, double x, double y, gpointer user);
 gboolean on_drop_channel(GtkDropTarget*, const GValue* value, double x, double y, gpointer user);
+/// The same drop, onto a **scope window's** plot: the target carries the window, the row is the
+/// window's own cell under the pointer, and the assignment lands in that window's row set.
+gboolean on_scope_drop_channel(GtkDropTarget*, const GValue* value, double x, double y, gpointer user);
+/// Plots `signal` on `row` of a scope window's row set (the signal page's *Plot on* buttons and the
+/// drop target both end here). False, with a notice, when the signal cannot be acquired or the plot
+/// holds four signals already.
+bool assign_signal_to_scope(App& app, App::ScopeWindow& scope, std::size_t signal, int row);
 /// 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);