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

@@ -9,6 +9,7 @@
 #include <plot/plot/plot.hpp>
 
 #include <array>
+#include <map>
 #include <memory>
 #include <string>
 
@@ -399,7 +400,30 @@ class RowSet {
   /// names beside it shifted sideways as signals were placed.
   static plot::Color unplotted_color();
 
+  /// The colour a signal is drawn in: the one the user chose for it if they chose one, the
+  /// positional palette entry otherwise.
+  ///
+  /// **The one resolver**, used by `install()` for the trace and by the panels for their chips.
+  /// A chip exists to say which trace on screen a panel row is about, so a chip that resolved
+  /// a colour by a different route than the trace is the single failure the chip cannot
+  /// survive -- and an override is exactly the state in which two routes would disagree.
+  plot::Color signal_color(const std::string& signal, int palette_index) const;
+  /// Gives `signal` the colour `rgb` (0xRRGGBB), by *name*: a palette entry is positional, so an
+  /// override held by index would move to another signal on the next CONFIG. Marks every row that
+  /// plots it dirty, because a trace's colour is fixed at `add_trace()` -- a new colour is a new
+  /// figure, which is the same path `assign()` already takes.
+  void set_signal_color(const std::string& signal, plot::u32 rgb);
+  /// Back to the palette entry. A no-op, and no rebuild, when there was no override.
+  void clear_signal_color(const std::string& signal);
+  /// Every override, for the session file. Ordered by name, so a saved session's colour
+  /// tables do not reshuffle between writes.
+  const std::map<std::string, plot::u32>& signal_colors() const noexcept { return signal_colors_; }
+
  private:
+  /// Marks every row with `signal` in a slot for rebuild. Not `assign()`: nothing about what
+  /// the slot *holds* changed, only the colour its trace has to be built with.
+  void mark_signal_dirty(const std::string& signal);
+
   /// Moves one row's *persistent* state -- what it plots, in which colours, where its
   /// cursors are -- onto another row. Deliberately not a `Row` assignment: a `Row` also
   /// carries the figure handles (`plot`, the axis and cursor ids) and the `SlotSeries`
@@ -440,6 +464,10 @@ class RowSet {
   double right_gutter_px_ = 0.0;
   bool y_gutter_reserved_ = false;
   std::array<Row, static_cast<std::size_t>(kMaxRows)> storage_{};
+  /// The colours the user chose, by signal name (see `set_signal_color()`). Sparse on purpose:
+  /// an absent entry means "the palette decides", which is what keeps a new CONFIG's signals
+  /// coloured without anything having to seed them.
+  std::map<std::string, plot::u32> signal_colors_;
   CursorMode cursor_mode_ = CursorMode::Vertical;
   bool cursors_on_ = false;
   bool relative_x_ = false;