ui: one channel list, and the math pane is gone

`rebuild_signal_list()` is handed `model.signals()`, and `append_math_signals_locked()` already
appends one synthetic entry per math channel -- "they go through the ordinary signal path on
purpose: a derived channel is a channel" -- so **every math channel was already a row of the
signal list**, with its tick, chip, name, unit and menu. The math pane listed the same channels a
second time, so this is mostly a deletion: `build_math_panel()`, `rebuild_math_pane()`,
`src/ui/math-panel.ui` and its resource entry, `App::math_list`, and the `math panel:` dump line.

What the one list gains:

- a non-selectable `MATH` divider before the first math row, carrying the `+` that creates a
  channel -- appended even when there are no math channels at all, because a `+` conditional on
  one existing could never create the first one;
- a math row's own menu: *Edit graph…*, *Default colour*, *Delete*. No Information and no
  Calibrate (calibration is applied at ingest, and a derived channel has no stream to describe),
  and no rename, because the node editor owns a channel's name and unit -- a second place to
  change them would be a second answer to the same question. An item dismisses the row's popover
  before opening or destroying anything from it;
- `App::math` mirrored from a math row's tick: `enable_locked()` mirrors it into the model, but
  `App::math` is the copy the session file is written from. The mirror sits *before* the
  `apply_math_channels()` in the `!on` path, which would otherwise push a stale `enabled = true`
  straight back into the model;
- a tick visible in a file view too: a derived channel is computed, and a file view has no
  acquisition to start, which is the other tick's question.

`rebuild_signal_list()` also publishes the list's own shape -- `rows`, `signals`, `math` -- and
the dump prints `divider=1` when `rows == signals + 1 + math`: the reading for a list that lost
its `+`.

Verified: `make test-ui` 14 files (was 15); `signals panel: labels=2 list=1 rows=9 signals=4
math=4 divider=1`; `[math-probe] 3 math channels`, every other line unchanged; no `math panel:`
line, and zero `Gtk-CRITICAL`.

src/ui_app.hpp

@@ -242,11 +242,10 @@ struct App {
   std::vector<MeasureResult> measure_results;
   GtkWidget* measures_list = nullptr;
   // --- math channels --------------------------------------------------------
-  /// The app's copy of the math channels, and the source of truth for the pane. Every change goes
-  /// through `apply_math_channels()`, which writes this and hands it to the model -- the model's own
-  /// copy is what the producer evaluates.
+  /// The app's copy of the math channels: what the signal list's ticks mirror into and what the
+  /// session file is written from. Every change goes through `apply_math_channels()`, which hands it
+  /// to the model -- the model's own copy is what the producer evaluates.
   std::vector<MathChannel> math;
-  GtkWidget* math_list = nullptr;
   /// The math editor's builder. The editor's window belongs to the builder's object list, so the builder is
   /// held for as long as the window is up and cleared on the *next* opening rather than with the window --
   /// freeing it under a live window frees the window with it. That is the source form's pattern.
@@ -739,6 +738,11 @@ struct App {
   int dbg_trigger_sensitive = 0;
   int dbg_trigger_items = 0;
   int dbg_trigger_selected = -1;
+  /// The signal list's shape, captured where the list is built: how many rows it holds, and how many
+  /// of them are streamed signals. The `MATH` divider and the math channels account for the rest, and
+  /// `rows == signals + 1 + math` is the invariant the dump checks -- a list that lost its `+`.
+  int dbg_signal_rows = 0;
+  std::size_t dbg_signal_plain = 0;
   int dbg_side_column_after_hide = 1;
   std::string dbg_mode_triggered;
   std::string dbg_window_text;
@@ -1147,6 +1151,9 @@ constexpr int kEventThumbH = 46;
 constexpr int kEventThumbMaxH = 104;
 inline int g_stats_phase = 0;
 inline std::vector<std::uint64_t> g_stats_n_before;
+/// The same for the tab-switch probe: the accumulator counts recorded while the Measure page was
+/// still current, so the report can say whether any of them advanced afterwards.
+inline std::vector<std::uint64_t> g_side_tab_n_before;
 inline double g_trigrenum_edge = 0.0;
 inline std::uint64_t g_trigrenum_latches = 0;
 inline ConditionProbe g_condition;
@@ -1229,6 +1236,13 @@ std::string signal_chip_markup(App& app, const std::vector<SignalInfo>& signals,
 void on_signal_color_chosen(GObject* source, GAsyncResult* res, gpointer user);
 void open_signal_color(App& app, std::size_t signal);
 void rebuild_signal_list(App& app, const std::vector<SignalInfo>& signals);
+/// The `MATH` divider row in the one channel list, and the `+` it carries.
+GtkWidget* make_math_divider(App& app);
+void on_math_add_clicked(GtkButton* button, gpointer user);
+/// The index in `App::math` of the channel a synthetic signal is named after, or `-1`.
+int math_index_for_signal(App& app, const std::string& name);
+void on_math_edit_clicked(GtkButton* button, gpointer user);
+void on_math_delete_clicked(GtkButton* button, gpointer user);
 void rebuild_trigger_signals(App& app);
 double window_limit(const App& app);
 void sync_window_display(App& app, double seconds);
@@ -1327,8 +1341,6 @@ void math_dialog_sync(MathDialog* d);
 void on_math_apply(GtkButton*, gpointer user);
 GtkWidget* math_row(const char* label, GtkWidget* widget, GtkWidget** row_out);
 void open_math_dialog(App& app, int edit);
-GtkWidget* build_math_panel(App& app);
-void rebuild_math_pane(App& app);
 GtkWidget* build_measures_panel(App& app);
 GtkWidget* build_cursors_panel(App& app);
 void on_cursors_toggled(GtkToggleButton* button, gpointer user);
@@ -1415,6 +1427,8 @@ gboolean measure_probe(gpointer user);
 gboolean measure_trace(gpointer user);
 gboolean stats_probe_report(gpointer user);
 gboolean stats_probe(gpointer user);
+gboolean side_tab_probe_report(gpointer user);
+gboolean side_tab_probe(gpointer user);
 gboolean pan_probe(gpointer user);
 gboolean arm_probe(gpointer user);
 gboolean trigrenum_probe_step3(gpointer user);