fix(figure): a following group keeps its whole window on the data

The offset of a following group was clamped to `retained` -- measured from the newest sample -- so
a pan (or a zoom-in anchored near an edge) could put the window's *right* edge exactly on the oldest
retained sample. That leaves the window's entire span to its left over data the scope never had: an
empty margin as wide as the view. The bound is about the whole window, so it is `retained - span` --
but only while the window *can* sit on the data. When the members retain less than a window's worth
(a ring still filling, or one just trimmed) nothing avoids a margin, and the older placement is the
honest one and stays: right edge on the newest sample, the shortfall on the left.

Test: a_following_group_keeps_its_whole_window_on_the_data -- asks to scroll ten spans past the
oldest sample and asserts the window is still a window, with its left edge on the data. The
existing `a_following_log_group_holds_decades` codified the old bound (`max == edge/10` after asking
for a decade of pan with far less than that retained); its log-space subject is unchanged and the
offset assertion is now the invariant above.

src/plot/figure.cpp

@@ -4,6 +4,7 @@
 #include <plot/plot/figure.hpp>
 
 #include <algorithm>
+#include <cstdio>
 #include <cmath>
 #include <cstddef>
 
@@ -277,13 +278,23 @@ bool Figure::place_live_window(XLink& group) {
   // The offset can outlive the window it names: a ring that dropped samples moves
   // the oldest x forward under it, so it is clamped against what the members hold
   // *now* -- measured in the same space, or a log group could hold an offset larger
-  // than everything it retains. An offset past that would put the window's right
-  // edge behind the oldest sample left, i.e. over data that is gone.
+  // than everything it retains.
+  //
+  // The bound is about the whole *window*, not just its right edge -- but only when the window
+  // *can* sit on the data. `retained >= span` is that case, and there the offset may not exceed
+  // `retained - span`: with the loose bound a scroll could put the window's right edge exactly on
+  // the oldest sample, which leaves the entire span to its left over data the scope never had --
+  // an empty margin as wide as the view, reached by a pan or by a zoom-in near that edge. When the
+  // window is *wider* than what the members retain (a ring still filling, or one just trimmed)
+  // nothing can avoid a margin, and the honest placement is the old one: the window's right edge
+  // on the newest sample, the shortfall on the left, which is what a scope that just started
+  // should look like.
   const bool log = !plots_.empty() && plots_.back().x_axis(0u).log;
   const f64 newest_space = to_link_space(live.max, log);
   const f64 retained =
       std::max(0.0, newest_space - to_link_space(live.min, log));
-  group.offset = std::clamp(group.offset, 0.0, retained);
+  const f64 reach = retained >= group.span ? retained - group.span : retained;
+  group.offset = std::clamp(group.offset, 0.0, std::max(0.0, reach));
   group.live_newest = live.max;
   group.has_live = true;
   const f64 right = newest_space - group.offset;