feat(input): a cursor can be unselectable, for a host's readout marks

A host that draws the result of a computation as a cursor -- a ruler at a level
it measured, a marker at a time it found -- must not let the user drag it: the
value belongs to the measurement, not to the pointer. Parking it outside the
axis and re-placing it every frame does not achieve that, because a drag is held
for the gesture's life and the marker follows the pointer between frames, so the
readout *looks* draggable however often it is put back.

`Cursor::selectable` defaults true; the controller's hit test skips an
unselectable cursor, so it is neither hovered nor grabbed and its hit radius
goes to whatever is behind it. Set through `Plot::set_cursor_selectable()`.

Tested by `an_unselectable_cursor_is_neither_hovered_nor_grabbed` in
tests/test_controller.cpp.

tests/test_controller.cpp

@@ -2309,3 +2309,35 @@ PLOT_TEST(double_click_needs_both_timestamps_and_the_window) {
   f.controller.on_pointer({410.0f, 200.0f, 0, 0, plot::input::Button::Left, 0, false, false,
                            true, 20.1});
 }
+
+// A readout cursor is drawn but not offered to the pointer: the host that keeps it is showing
+// a computed value, and a drag on it would be a drag on a number rather than on an instrument.
+// The hit test is where that is enforced -- re-placing the marker every frame would only fight
+// the drag, which is the shape this replaces.
+PLOT_TEST(an_unselectable_cursor_is_neither_hovered_nor_grabbed) {
+  plot::Plot p;
+  p.set_viewport({0, 0, 800, 400});
+  const u32 ax = p.add_x_axis({"t", {0.0, 100.0}, false, plot::AxisPlace::Bottom, false});
+  const u32 readout = p.add_cursor(50.0, plot::Color::hex(0x00FF00));
+  p.set_cursor_selectable(readout, false);
+  PLOT_CHECK(p.cursor(readout).visible);        // drawn all the same
+  PLOT_CHECK(!p.cursor(readout).selectable);
+  // A normal cursor right beside it stays grabbable, so the flag is a property of one cursor
+  // and not a switch on the plot.
+  const u32 normal = p.add_cursor(50.0, plot::Color::hex(0xFF0000));
+
+  plot::input::Controller c(p);
+  c.set_viewport({0, 0, 800, 400});
+  const f32 sx = screen_x_of(p, ax, 50.0);
+  c.on_pointer({sx, 200, 0, 0, plot::input::Button::Left, 0, false, false, false});
+  PLOT_CHECK(c.hovered_cursor() == normal);     // the readout is not in the running
+
+  // Press and move: the pointer grabbed the *normal* cursor (the two are at the same x, so
+  // the readout would otherwise be the nearer hit), and the readout's own x never moves.
+  const f64 before = p.cursor(readout).x;
+  c.on_pointer({sx, 200, 0, 0, plot::input::Button::Left, 0, true, true, false});
+  PLOT_CHECK(c.grabbed_cursor() == normal);
+  c.on_pointer({sx + 40, 200, 40, 0, plot::input::Button::Left, 0, true, false, false});
+  PLOT_CHECK_NEAR(p.cursor(readout).x, before, 1e-12);
+  PLOT_CHECK(c.grabbed_cursor() == normal);
+}