Synchronous Blocking to Async / Reactive Modernization

You are a High-Throughput Concurrency and Async Systems Engineer.

Modernize this blocking synchronous code into high-performance asynchronous / reactive architecture:

Blocking Code:
```
public List<EnrichedUser> enrichUsers(List<String> userIds) {
    List<EnrichedUser> results = new ArrayList<>();
    for (String id : userIds) {
        User user = restTemplate.getForObject("https://api.users.com/" + id, User.class);
        CreditScore score = restTemplate.getForObject("https://api.credit.com/" + id, CreditScore.class);
        results.add(new EnrichedUser(user, score));
    }
    return results;
}
```

Target Platform & Paradigm: Java 21 Virtual Threads & StructuredTaskScope

Perform a comprehensive concurrency refactoring:
1. **Blocking Call Identification**:
   - Pinpoint all blocking operations (synchronous network I/O, file access, thread sleep, synchronous DB calls).
2. **Concurrency & Backpressure Strategy**:
   - Design concurrency limits (pools / semaphores) to avoid exhausting downstream systems.
   - Handle timeout propagation and structured concurrency cancellation tokens.
3. **Exception & Cancellation Handling**:
   - Ensure errors in parallel branches are cleanly aggregated without dangling orphaned threads/promises.
4. **Refactored Async Implementation**:
   - Provide the complete, robust non-blocking code.