[kammce]

Adds mem::for_each_run(), which walks two scatter spans side by side, one contiguous run at a time.

std::array<int, 2> a = { 1, 2 };
std::array<int, 3> b = { 3, 4, 5 };
std::array<int, 4> c = { 6, 7, 8, 9 };
std::array<int, 1> d = { 10 };
std::array<int, 1> e = { 11 };

// Runs: ({1, 2}, {6, 7}), ({3, 4}, {8, 9}), ({5}, {10}), ({}, {11})
mem::for_each_run(mem::scatter_span<int>{ a, b },
                  mem::scatter_span<int>{ c, d, e },
                  [](std::span<int> p_first, std::span<int> p_second) {
                    // ...
                  });

Behavior

• Each call gets the longest pair of spans that starts at the same logical position and is contiguous in both scatter spans. A run ends at whichever chunk boundary comes first.
• Every element of both scatter spans is passed exactly once, in order. Empty chunks are skipped.
• While both scatter spans have elements left, the two spans of a run are the same size. Once one runs out, its span is empty and the run is the rest of the other's current chunk.
• The two scatter spans can have different element types, e.g. scatter_span<byte const> for data going out and scatter_span<byte> for data coming in.
• Each run costs O(1), with no allocation. sub_scatter_span() would walk the chunks from the start on every call.

Why

A full duplex bus moves two caller-supplied buffers in lockstep, and their chunk boundaries rarely line up. The STM32 SPI driver in libhal-arm-mcu needs this to hand each run to DMA, and a hal::spi on any other platform would need the same walk. A single buffer is already covered by a range-for over its chunks.

Testing

Five new unit tests cover:

• splitting at the first boundary;
• empty spans once one side runs out;
• skipping empty chunks;
• writing through to the elements;
• two empty scatter spans.

The build and all tests pass with LLVM 23, and pre-commit passes.

[kammce]

Lgtm except for the places where () should wrap up arithmetic

[kammce]

Lgtm