I'm not entirely sure if this abstraction is worth it. Using it just as a forward iterator might be fine though, not sure. Maybe the concept can be generalized.
I wonder if adding a random access iterator here provides any real benefit, but it could be worth a try. It feels like it would add quite some overhead to element access when no expensive preprocessing is done.

One thing I don't understand is why this inherits from Span. A multiple span is not a span.

The overhead for each element access is not ideal, but when you need this functionality, the alternative is usually copying all the data in all the spans.

The random_access_iterator is required for std::nth_element() which I want to use for computing the median in the Attribute Statistic node.

My thinking for the inheritance from Span was that this way you could just write your functions to work with Span, but you can also call them with a MultiSpan. You'd only need a single function for both, and let the iterator handle the iteration. For the user, a MultiSpan should behave like a regular Span as much as possible.

Example of how the inheritance could allow prettier code:

int sum(Span<int> span) {
    int sum = 0;
    for (int value : span) {
        sum += value;
    }
}

Vector<int> a = {1, 2, 3};
MutableSpan<int> a_span = a;

Vector<int> b = {4, 5, 6, 7};
MutableSpan<int> b_span = b;

Vector<MutableSpan<int>> spans_vector = {a_span, b_span};
Span<MutableSpan<int>> spans = spans_vector.as_span();
MultiSpan<int> multispan = MultiSpan<int>(spans);

sum(a_span)
sum(multispan)

As Jacques pointed out, what I explained in my previous comment is not possible in C++.

The way to decouple algorithms from datastructures in C++ is to use templated functions that take iterators as arguments.

So what I'll try is to define only a special iterator to iterate over a Span<MutableSpan<T>> (so no MultiSpan class anymore). The statistics for the Attribute Statistic node will then be rewritten to take iterators as inputs.

Current plan: keep MultiSpan, it's job is to provide a .begin() and .end() for the iterator. Then use algorithms that work with iterators, see the sum test for an example with std::accumulate().