feat(capture): M11 batch capture - one bank sample per selected item / razor area

Pure batch_capture module (plan + mixed-result aggregation, unit-tested);
CAPTURE_BATCH_ITEMS/RAZOR actions with transient per-unit selection restored
on all paths, per-unit invariants + provenance, single persist.
Conform-on-insert already shipped.

src/batch_capture.h

@@ -0,0 +1,100 @@
+#pragma once
+// batch_capture — the REAPER-free logic behind M11 batch capture (one action fires
+// N captures: one bank sample per selected item / per razor area).
+//
+// PURE MODULE (CLAUDE.md §load-bearing split): NO REAPER types, NO SWELL, NO
+// vendor/ includes. Standard library only. The batch shell (main.cpp) reads the DAW
+// state (selected items -> their exact bounds; every track's P_RAZOREDITS -> areas)
+// and hands the raw ranges here so the genuinely-pure, easy-to-get-wrong pieces are
+// unit-tested outside the DAW:
+//
+//   1. planCaptureUnits: an ordered list of (start,end) source ranges -> an ordered
+//      list of CaptureUnit, each carrying its 1-based ordinal and validated bounds.
+//      Empty/inverted ranges are DROPPED (mirrors the offline backend's own
+//      end>start guard) so a zero-length item/area never produces a stray render.
+//      Order is preserved: unit ordinals count only the KEPT units, so a batch of
+//      three valid items yields ordinals 1,2,3 regardless of dropped neighbors.
+//   2. BatchOutcome: order-preserving aggregation of per-unit results into a summary
+//      (succeeded / failed counts + the ordered list of failures) so the shell can
+//      report a mixed result with one console line and no partial-corruption
+//      ambiguity. The AGGREGATION is pure; the render loop that feeds it is shell.
+//
+// Range is the ONLY thing that varies per unit here. FX scope (item vs track) is a
+// per-ACTION constant the shell already owns (fxBypassPlanFor); it is not a
+// per-unit field. Item-batch uses item scope; razor-batch uses track scope — the
+// shell passes the scope straight through to each render, unchanged from the
+// single-capture path.
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace reasampler {
+
+// One capture in a batch: an exact source range plus its 1-based ordinal within the
+// KEPT set. The ordinal disambiguates per-unit file stems (the offline backend's
+// unique tag is 1-second-granular, so a fast batch could otherwise collide N files
+// onto one name) and labels a failure in the summary.
+struct CaptureUnit {
+    int    ordinal      = 0;    // 1-based, counts kept units only
+    double startSeconds = 0.0;  // exact — no rounding
+    double endSeconds   = 0.0;
+};
+
+// A source range handed in by the shell (a selected item's [pos, pos+len] or one
+// razor area's [start, end]). Kept as a distinct type from CaptureUnit so the input
+// (raw, possibly-invalid) and the output (validated, ordinal-assigned) do not share
+// a shape by accident. Named BatchRange (not SourceRange) to avoid collision with
+// bank_model's SourceRange, which carries PPQ fields this planner does not need.
+struct BatchRange {
+    double startSeconds = 0.0;
+    double endSeconds   = 0.0;
+};
+
+// Validates + orders a batch's source ranges into capture units. Preserves input
+// order; DROPS every range with end <= start (empty/inverted) so no stray render is
+// planned; assigns 1-based ordinals over the KEPT units. An empty input (no selected
+// item / no razor area) yields an empty plan — the shell reports "nothing to batch"
+// and writes nothing (the same no-op posture the single-capture path takes).
+std::vector<CaptureUnit> planCaptureUnits(const std::vector<BatchRange>& ranges);
+
+// The per-unit verdict the shell records after each render attempt, in unit order.
+struct BatchUnitResult {
+    int         ordinal = 0;     // the CaptureUnit's ordinal this result is for
+    bool        ok      = false; // true iff the render + bank-add succeeded
+    std::string detail;          // failure reason (empty on success) — for the summary
+};
+
+// Order-preserving aggregation of a batch's per-unit results. Built incrementally by
+// the shell (record() after each unit) so a mid-batch failure is captured without
+// aborting the remaining units (no partial corruption: each unit is independent, and
+// the selection is restored on every exit path by the shell's RAII guard).
+class BatchOutcome {
+public:
+    // Records one unit's verdict. Order of calls IS the reported order.
+    void record(int ordinal, bool ok, std::string detail = {});
+
+    std::size_t total()     const { return results_.size(); }
+    std::size_t succeeded() const;
+    std::size_t failed()    const;
+
+    const std::vector<BatchUnitResult>& results() const { return results_; }
+
+    // The ordered subset of results that failed (ok == false). For the summary line.
+    std::vector<BatchUnitResult> failures() const;
+
+    // A single human summary line for the console (explicit-action response — allowed
+    // by the console policy; a batch-completion summary with failure counts qualifies,
+    // per-unit success spam does not). `noun` is the unit word ("item" / "razor area").
+    // Examples:
+    //   all-success, 3 items : "ReaSampler batch capture: 3 items captured."
+    //   partial, 3 of 5      : "ReaSampler batch capture: 3 of 5 items captured "
+    //                          "(2 failed: #2, #4)."
+    //   empty plan           : "ReaSampler batch capture: nothing to capture."
+    std::string summaryLine(const std::string& noun) const;
+
+private:
+    std::vector<BatchUnitResult> results_;
+};
+
+} // namespace reasampler