feat: a signal's chip is clickable, so a trace's colour is the user's to choose

Clicking the coloured chip in the signal list opens a GtkColorDialog and the
colour it returns overrides that signal's palette entry. Held by name, like
every other identity here, and persisted as a session `[[color]]` table.

RowSet::signal_color() becomes the one resolver: install() builds the trace
through it and all three chip sites read it, because a chip exists to say which
trace a row is about and an override is exactly the state in which two routes to
a colour would disagree. A grey chip names no trace and so is not clickable, and
the way back is `Default colour` in the signal's menu -- a setting with no undo
is a trap.

The gesture sits on the existing label rather than in a GtkButton: padding on
this row is what made the signal list twice as tall once. It claims its sequence
so a click on the chip cannot become the start of a row drag.

UDPSCOPE_PROBE_COLOR_MS reads the result out of plot::Plot::trace() and out of
the chip's own markup, with an override in no palette slot, so neither leg can
pass by asking the resolver what it already said.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/plot_host.cpp

@@ -69,6 +69,40 @@ plot::Color RowSet::palette_color(int index) {
 
 plot::Color RowSet::unplotted_color() { return plot::Color::hex(kUnplottedColor); }
 
+plot::Color RowSet::signal_color(const std::string& signal, int palette_index) const {
+  const auto it = signal_colors_.find(signal);
+  if (it != signal_colors_.end()) return plot::Color::hex(it->second);
+  return palette_color(palette_index);
+}
+
+void RowSet::mark_signal_dirty(const std::string& signal) {
+  for (int i = 0; i < kMaxRows; ++i) {
+    const Row& r = row(i);
+    for (int s = 0; s < kSlotsPerRow; ++s) {
+      if (r.signal_name[static_cast<std::size_t>(s)] != signal) continue;
+      row_dirty_[static_cast<std::size_t>(i)] = true;
+      break;
+    }
+  }
+}
+
+void RowSet::set_signal_color(const std::string& signal, plot::u32 rgb) {
+  if (signal.empty()) return;
+  // Masked to 24 bits: the palette is `0xRRGGBB` and `Color::hex()` reads it as such, so an alpha
+  // byte left in the high octet by a caller converting from a `GdkRGBA` would be silently ignored
+  // by the plot and silently written to the session file.
+  const plot::u32 want = rgb & 0x00FFFFFFu;
+  const auto it = signal_colors_.find(signal);
+  if (it != signal_colors_.end() && it->second == want) return;
+  signal_colors_[signal] = want;
+  mark_signal_dirty(signal);
+}
+
+void RowSet::clear_signal_color(const std::string& signal) {
+  if (signal_colors_.erase(signal) == 0) return;
+  mark_signal_dirty(signal);
+}
+
 RowSet::RowSet() { rebuild_all(); }
 
 void RowSet::set_row_count(int rows) {
@@ -130,8 +164,8 @@ void RowSet::install(Row& r, int /*row_index*/, plot::Plot& p) {
       {"", {-1.0, 1.0}, true, plot::AxisPlace::Left, false, plot::TickFormat::Si});
   for (int s = 0; s < kSlotsPerRow; ++s) {
     const std::size_t i = static_cast<std::size_t>(s);
-    r.plot->add_trace(
-        {&r.slots[i], palette_color(r.color_index[i]), 1.2f, r.axis_x, r.axis_y, r.name[i]});
+    r.plot->add_trace({&r.slots[i], signal_color(r.signal_name[i], r.color_index[i]), 1.2f,
+                       r.axis_x, r.axis_y, r.name[i]});
   }
   r.cursor_a = r.plot->add_cursor(0.0, plot::Color::hex(kCursorAColor));
   r.cursor_b = r.plot->add_cursor(0.0, plot::Color::hex(kCursorBColor));