fix: time a FIRST_SAMPLE stream by its cadence, not by a second stamp

A UDPS_TIME_FIRST_SAMPLE time signal carries one meaningful value -- the
batch's first sample -- but a scalar signal in Accumulate mode still occupies
num_samples slots on the wire, which a producer fills by repeating that
anchor. Deriving the step from value_of(n - 1) therefore came out as zero, so
every sample of a frame landed on one x, the degeneracy guard tripped, and the
whole stream was timed by packet arrival instead. On a 1 MS/s source that
arrival clock is not monotonic within a frame: the export's time column held
90559 order breaks.

Space the batch by the cadence, exactly as the LAST_SAMPLE branch beside it
already dates its own batch backwards. The export's time column is now
strictly increasing (0 duplicates, 0 backwards steps) and reads the declared
1 MS/s.

mock_udpstreamer gains --time-mode {full,first}; it could only emit
FULL_ARRAY, so nothing exercised this branch. In 'first' it repeats the anchor
across the batch's wire slots -- the shape that produced the defect -- while
still generating the waveforms from the real per-sample stamps.

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

src/acquisition.cpp

@@ -183,9 +183,16 @@ std::uint32_t Acquisition::build_stamps(const udps_frame_t* frame, int time_sign
         used_stream_time = true;
         break;
       case UDPS_TIME_FIRST_SAMPLE: {
+        // Only element 0 is meaningful here: the producer stamps the batch's first
+        // sample and says nothing about the rest, so the cadence has to space them --
+        // exactly as LAST_SAMPLE below dates its batch backwards from its anchor.
+        // Deriving a step from `value_of(n - 1)` instead cannot work: a scalar signal
+        // in Accumulate mode still occupies `num_samples` slots on the wire, and a
+        // producer fills them by repeating the anchor, so the step came out as zero
+        // and every sample of the frame landed on one x. The degeneracy guard below
+        // then threw the whole stream onto the arrival clock.
         const double anchor = value_of(0);
-        const double step = n > 1 ? (value_of(n - 1) - anchor) / double(n - 1) : period;
-        for (std::uint32_t k = 0; k < n; ++k) stamps_[k] = anchor + double(k) * step;
+        for (std::uint32_t k = 0; k < n; ++k) stamps_[k] = anchor + double(k) * cadence;
         used_stream_time = true;
         break;
       }