Greptile Summary

This PR adds graceful Ctrl+C handling to the two phases of the bench catchup path that previously had no cancellation support: the pre-catchup delay (tokio::time::sleep) and the catchup-read loop (tokio::time::timeout_at). It achieves this through two small, well-scoped async helper functions (wait_or_cancel and timeout_or_cancel) backed by two purpose-built outcome enums, and covers each helper with unit tests for all three observable outcomes.

Key changes:

• wait_or_cancel(delay, cancel) — races a sleep against a cancellation future, returns DelayOutcome::{Elapsed,Cancelled}.
• timeout_or_cancel(deadline, future, cancel) — wraps tokio::time::timeout_at and adds a cancel arm, returning CatchupOutcome::{Item,TimedOut,Cancelled}.
• Both are wired into run() at the catchup-delay site and inside the catchup-read loop; Cancelled in either case causes an early Ok(()) return.
• Five #[tokio::test] cases cover every branch of both helpers using future::ready / future::pending as deterministic stand-ins.

Confidence Score: 5/5

• This PR is safe to merge; the change is well-scoped, follows existing patterns, and all new logic is covered by unit tests.
• The helpers are simple tokio::select! wrappers with exhaustively matched outcome enums. Tests are deterministic (using future::ready/future::pending), and the pattern of constructing a fresh ctrl_c() future per iteration is consistent with the main bench loop. No data races, no unsafe code, no unhandled edge cases.
• No files require special attention

Sequence Diagram

sequenceDiagram
    participant User
    participant run() as run()
    participant wait_or_cancel
    participant timeout_or_cancel
    participant catchup_stream

    run()->>wait_or_cancel: wait_or_cancel(catchup_delay, ctrl_c())
    alt ctrl_c fires first
        User->>wait_or_cancel: Ctrl+C
        wait_or_cancel-->>run(): DelayOutcome::Cancelled
        run()-->>User: return Ok(())
    else delay elapses
        wait_or_cancel-->>run(): DelayOutcome::Elapsed
    end

    loop catchup read loop
        run()->>timeout_or_cancel: timeout_or_cancel(deadline, catchup_stream.next(), ctrl_c())
        alt ctrl_c fires first
            User->>timeout_or_cancel: Ctrl+C
            timeout_or_cancel-->>run(): CatchupOutcome::Cancelled
            run()-->>User: return Ok(())
        else deadline exceeded
            timeout_or_cancel-->>run(): CatchupOutcome::TimedOut
            run()-->>User: return Err(BenchVerification)
        else item received
            catchup_stream-->>timeout_or_cancel: Some(Ok(sample))
            timeout_or_cancel-->>run(): CatchupOutcome::Item(Some(Ok(sample)))
        else stream ended
            catchup_stream-->>timeout_or_cancel: None
            timeout_or_cancel-->>run(): CatchupOutcome::Item(None)
            run()-->>run(): break
        end
    end

_{Last reviewed commit: 71832d8}