Add structured concurrency wrapper for CompletableFuture

[cconstable]

What was changed

Add a small, nonblocking structured concurrency-like wrapper for CompletableFuture. Loosely inspired by Java 25 StructuredTaskScope and Swift TaskGroup.

Allows for us to write this:

CompletableFuture<List<String>> result =
    TaskScope.withScope( // 1. create a scope
        scope -> {
            scope.attach(startWork()); // 2. add tasks to the scope
            scope.attach(startMoreWork())
                .thenApply(value -> doDownstreamWork(value));

            return scope.awaitAll(); // 3. collect results
        });

result.get();        // 4. get results a usual
// or
result.cancel(true); // 5. cancel (propagates to all child tasks)

See the README for more details.

Why?

I'm doing extstore work and fan-in / fan-out + proper cancellation + error handling boilerplate with raw CompletableFuture is tedious and error prone. Scoped task creation gives us correctness guarantees and better ergonomics. I noticed other disparate abstractions solving similar problems and provided a general solution.

Checklist

I wrote and generated a ton of tests for this and also ran some "stress" tests locally. Since this is just a wrapper on top of CompletableFuture and we aren't creating/using our own executors or threading abstractions it's not as scary of a thing as it looks.

[cconstable]

cancellation is an error but it's not something we can "recover from" so we should just immediately surface cancellations (skip the user supplied transform)

[cconstable]

• the only "public" part of this PR
• meant to serve as a general purpose cancellation token
• can replace existing bespoke tokens e.g. ActivityCancellationToken

[cconstable]

This is the main usage point:

scope.attach(someAsyncWork());

It lifts a CompletableFuture into the structured scope. It's the bridge from the unstructured CF world into the structured one. We return a TaskChain rather than a CompletableFuture so callers can chain downstream work (via map, recover, etc) without leaving the scope. It also does not expose blocking operations and foot-guns like exceptionally that break cancellation.

[cconstable]

This isn't used in this PR but it's a natural part of the using this abstraction:

scope.awaitAll(ListUtils::flatten);

It's also being used in the branch I have this relies on this branch.