ui: the tab glyphs are 32x16 pairs, drawn twice as wide

Each tab's icon is now two motifs side by side instead of one in a 16px square: the Measure pill is the
two cursors beside the ruler, the Signals pill the trigger beside three channel rows. A 16px cell carries
one motif — squeezing a pair into it is what turned both into a smear — and the pill has the width for a
pair in a 300px column with two pills in it.

Two measurements decided the size, both of which I had wrong from the outside:

- **GDK paints an icon into a square box whatever the document's aspect.** `gtk_icon_theme_lookup_icon()`
  at 32 reports a `32x32` paintable for a 32x16 document, and librsvg fits it: rendered with aspect kept,
  the artwork comes out `32x16` inside a 32 request. So the pair is letterboxed, not stretched, and
  `pixel_size` 32 draws it at exactly the size it is written — 1:1, so the 2px bars stay crisp. A
  fractional scale (24 or 48) is what would blur them, which is why nothing here is drawn at one.
- **The bar does not get taller for it.** `switcher: … icon=32x32 size=308x36`: 36px is what the switcher
  measured with 16px icons too, because the pill's fixed height takes a 32px box without growing.

Both glyphs were drawn and then read back as ink maps rather than trusted: the first drafts came out at
39% and 44% ink (a blot beside the house 25–36%), and the tab bar is the last place a shape can be
checked, since no screenshot works under this X setup. The finished two measure 23% and 33%.

Verified: `switcher: policy=narrow pills=2 labels=0 names=2 icon=32x32 size=308x36`;
`page icons: measure=udpscope-tab-measure-symbolic(ok) signals=udpscope-tab-signals-symbolic(ok)`;
`[side-tab-probe] … advanced=4`; the Preferences dialog opened in the same run with no "not present";
`make test-ui` 14 files; zero `Gtk-CRITICAL`. The icons' GResource blob is 11661 bytes, still over the
C99 limit, so the clean-build warning count stays four.

src/icons/scalable/actions/udpscope-tab-measure-symbolic.svg

@@ -1,23 +1,26 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- SPDX-License-Identifier: MIT -->
 <!-- SPDX-FileCopyrightText: 2026 Martino Ferrari -->
-<!-- The Measure tab: the cursors and the ruler they read against, in one glyph. Two markers, each a
-     cap over a dashed shaft, stand across a ruler: the ruler is two bars with three hanging ticks.
-     The ruler's ends are open on purpose. A closed frame puts four more pixels of ink at the left
-     and right edges, which at this size is what turns a ruler into a rectangle. The shafts stop at
-     the bars rather than crossing them, the way a marker on a plot sits over the scale. Whole
-     pixels, filled `path`s wound the same way, and an ink fraction of 36%, in line with the ruler
-     and the cursors it is made of. -->
-<svg height="16px" width="16px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
-  <path fill="#2e3436" d="M3 1 H7 V3 H3 Z
-                          M9 1 H13 V3 H9 Z
-                          M4 3 H6 V6 H4 Z
-                          M10 3 H12 V6 H10 Z
-                          M4 14 H6 V16 H4 Z
-                          M10 14 H12 V16 H10 Z
-                          M2 6 H14 V8 H2 Z
-                          M2 12 H14 V14 H2 Z
-                          M4 8 H5 V11 H4 Z
-                          M8 8 H9 V10 H8 Z
-                          M12 8 H13 V11 H12 Z"/>
+<!-- The Measure tab, as two motifs side by side in a 32x16 cell: the two cursors on the left (a cap
+     over a dashed shaft, the shape the toolbar's cursors button has) and the ruler they read against
+     on the right. The ruler is a closed frame with its ticks hanging inside it, which needs
+     `fill-rule="evenodd"`: the ticks sit inside the frame's hole, three crossings deep, so they fill
+     rather than punching a second hole. The cursors do not overlap the ruler, so one evenodd path
+     carries both without either cancelling. Rendered at 32, i.e. 1:1, so the 2px bars stay crisp,
+     and every coordinate is a whole pixel of the cell. As with the Signals glyph, GDK's box is
+     square whatever the document's aspect: this pair is letterboxed, not stretched. -->
+<svg height="16px" width="32px" viewBox="0 0 32 16" xmlns="http://www.w3.org/2000/svg">
+  <path fill="#2e3436" fill-rule="evenodd" d="M1 1 H7 V4 H1 Z
+                          M3 5 H6 V8 H3 Z
+                          M3 9 H6 V12 H3 Z
+                          M3 13 H6 V16 H3 Z
+                          M9 1 H15 V4 H9 Z
+                          M11 5 H14 V8 H11 Z
+                          M11 9 H14 V12 H11 Z
+                          M11 13 H14 V16 H11 Z
+                          M17 4 H31 V12 H17 Z
+                          M19 6 H29 V10 H19 Z
+                          M21 6 H22 V9 H21 Z
+                          M25 6 H26 V9 H25 Z
+                          M28 6 H29 V8 H28 Z"/>
 </svg>

src/icons/scalable/actions/udpscope-tab-signals-symbolic.svg

@@ -1,20 +1,25 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- SPDX-License-Identifier: MIT -->
 <!-- SPDX-FileCopyrightText: 2026 Martino Ferrari -->
-<!-- The Signals tab: the trigger *and* the channel list it acts on, in one glyph. A rising edge
-     crossing a dashed level is the trigger as the toolbar already draws it; below it, two rows of a
-     colour chip and a name are the channel list, which is what the page mostly is. Two rows and not
-     three, so the edge and the list each get half the cell: at 16px a third row costs the edge its
-     clearance and the whole thing turns into a grid. Whole pixels, filled `path`s wound the same
-     way, and the 2px bars match the house stroke weight. -->
-<svg height="16px" width="16px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
-  <path fill="#2e3436" d="M6 1 H8 V6 H6 Z
-                          M6 1 H15 V3 H6 Z
-                          M0 5 H2 V7 H0 Z
-                          M3 5 H5 V7 H3 Z
-                          M12 5 H14 V7 H12 Z
-                          M1 9 H4 V12 H1 Z
-                          M6 10 H14 V12 H6 Z
-                          M1 13 H4 V15 H1 Z
-                          M6 13 H14 V15 H6 Z"/>
+<!-- The Signals tab, as two motifs side by side in a 32x16 cell: the trigger on the left (a rising
+     edge crossing a dashed level, the shape the toolbar's trigger button has) and three rows of a
+     colour chip and a name on the right, which is the channel list the tab mostly is. Wider than
+     tall because it has to hold *two* motifs: a 16px square cell can carry one, and squeezing the
+     pair into it is what turns them into a smear. The pill renders this at 32, i.e. 1:1, so the 2px
+     bars stay crisp; a fractional scale would blur them, which is why every coordinate is a whole
+     pixel. GDK paints an icon into a *square* box whatever the document's aspect, so this pair is
+     letterboxed in a 32x32 box rather than stretched (measured: a 32x16 render inside a 32 request).
+     All subpaths are filled `path`s wound the same way. -->
+<svg height="16px" width="32px" viewBox="0 0 32 16" xmlns="http://www.w3.org/2000/svg">
+  <path fill="#2e3436" d="M4 2 H6 V12 H4 Z
+                          M6 2 H14 V4 H6 Z
+                          M0 7 H2 V9 H0 Z
+                          M8 7 H10 V9 H8 Z
+                          M12 7 H14 V9 H12 Z
+                          M18 2 H21 V5 H18 Z
+                          M23 3 H30 V5 H23 Z
+                          M18 7 H21 V10 H18 Z
+                          M23 8 H30 V10 H23 Z
+                          M18 12 H21 V15 H18 Z
+                          M23 13 H30 V15 H23 Z"/>
 </svg>

src/ui.cpp

@@ -2903,6 +2903,17 @@ void name_side_tabs(App& app) {
       }
     };
     hide_labels(pill);
+    // The tabs' glyphs are 32x16 documents, and the pill has the width for them: drawn at 32 they are
+    // 1:1, so both motifs sit side by side at the size they were authored at and the 2px bars stay
+    // crisp. A 16px box would scale the pair down to a smear, and a fractional scale would blur it.
+    const std::function<void(GtkWidget*)> size_images = [&](GtkWidget* w) {
+      if (GTK_IS_IMAGE(w)) gtk_image_set_pixel_size(GTK_IMAGE(w), 32);
+      for (GtkWidget* c = gtk_widget_get_first_child(w); c != nullptr;
+           c = gtk_widget_get_next_sibling(c)) {
+        size_images(c);
+      }
+    };
+    size_images(pill);
     app.side_tabs_named = true;
   }
 }
@@ -5674,9 +5685,12 @@ int run_ui(int argc, char** argv, const Config& cfg, ScopeModel& model, Acquisit
                 app.dbg_trigger_sensitive, app.dbg_switcher_visible,
                 rows.cursors_visible() ? 1 : 0, rows.time_window(),
                 app.window_limit_s);
-    std::printf("[udpscope]   switcher: policy=%s pills=%d labels=%d names=%d\n",
+    std::printf("[udpscope]   switcher: policy=%s pills=%d labels=%d names=%d icon=%dx%d "
+                "size=%dx%d\n",
                 app.dbg_switcher_policy == 0 ? "narrow" : (app.dbg_switcher_policy == 1 ? "wide" : "?"),
-                app.dbg_switcher_pills, app.dbg_switcher_labels, app.dbg_switcher_names);
+                app.dbg_switcher_pills, app.dbg_switcher_labels, app.dbg_switcher_names,
+                app.dbg_switcher_icon_w, app.dbg_switcher_icon_h, app.dbg_switcher_w,
+                app.dbg_switcher_h);
     std::printf("[udpscope]   mode with trigger on: %s\n", app.dbg_mode_triggered.c_str());
     std::printf("[udpscope]   trigger marker x=%.3f, view x_max=%.3f; model trigger_time=%.3f "
                 "valid=%d\n",

src/ui_app.hpp

@@ -219,6 +219,14 @@ struct App {
   int dbg_switcher_pills = -1;
   int dbg_switcher_labels = -1;
   int dbg_switcher_names = -1;
+  /// The pills' icon as it is *rendered*: a 32x16 glyph in a 32px box is drawn 1:1, which is what
+  /// keeps its 2px bars crisp.
+  int dbg_switcher_icon_w = -1;
+  int dbg_switcher_icon_h = -1;
+  /// The switcher's own size, beside it: the pills carry 32px icon boxes now, so the tab bar's height
+  /// is what it costs.
+  int dbg_switcher_w = -1;
+  int dbg_switcher_h = -1;
   int dbg_switcher_policy = -1;
   /// Whether `name_side_tabs()` has named the pills: it can only run once the switcher is mapped.
   bool side_tabs_named = false;

src/ui_probe.cpp

@@ -78,6 +78,28 @@ gboolean exit_probe_step3(gpointer user) {
   a->dbg_signal_h = gtk_widget_get_height(a->signal_panel);
   a->dbg_trigger_w = gtk_widget_get_width(a->trigger_panel);
   a->dbg_trigger_h = gtk_widget_get_height(a->trigger_panel);
+  // The switcher's icon as it is *rendered*: a 32x16 glyph in a 32px box draws 1:1, which is what
+  // keeps its 2px bars crisp rather than blurred by a fractional scale. Read here and not on the
+  // first tick, where the window has not been allocated yet and every widget still measures 0x0.
+  if (a->side_switcher != nullptr) {
+    a->dbg_switcher_w = gtk_widget_get_width(a->side_switcher);
+    a->dbg_switcher_h = gtk_widget_get_height(a->side_switcher);
+  }
+  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)) {
+    const std::function<void(GtkWidget*)> measure_icon = [&](GtkWidget* node) {
+      if (GTK_IS_IMAGE(node) && gtk_widget_get_mapped(node)) {
+        a->dbg_switcher_icon_w = std::max(a->dbg_switcher_icon_w, gtk_widget_get_width(node));
+        a->dbg_switcher_icon_h = std::max(a->dbg_switcher_icon_h, gtk_widget_get_height(node));
+      }
+      for (GtkWidget* c = gtk_widget_get_first_child(node); c != nullptr;
+           c = gtk_widget_get_next_sibling(c)) {
+        measure_icon(c);
+      }
+    };
+    measure_icon(pill);
+  }
   // The height of one signal row, which is the thing "the channel toggle is too tall"
   // was about. The panel's own height cannot stand in for it: it also covers the
   // heading, the hint and the box margins.