Multi-tenant fan-out for @service

public sealed interface ContextValueRegistration<T> {
    String name();
    Class<T> type();

    record Scalar<T>(...) implements ContextValueRegistration<T> {}  // from R45

    record FanOut<T>(String name, Class<T> type,
                     Function<DataFetchingEnvironment, Collection<T>> resolver,
                     Optional<DslContextPerElement> dslContext)
        implements ContextValueRegistration<T> {}
}

public interface DslContextPerElement {
    DSLContext open(DataFetchingEnvironment env, Object element);
}

registry.register(new FanOut<>("tenantId", String.class,
    env -> {
        UserInfo ui = graphQlContext(env).get("userInfo");
        return ui.getInstitusjonsroller().keySet();
    },
    Optional.of((env, element) -> graphQlContext(env)
        .get("connectionManager")
        .createDSLContextWithSettings((String) element))));

case ParamSource.Context ctx -> registry.lookup(param.name()) match {
    case Scalar(_, type, _) ->
        // R45 emission, unchanged
        CodeBlock.of("graphitronContext(env).getContextArgument(env, $S)", param.name());
    case FanOut(_, _, _, _) ->
        CodeBlock.of("$L", fanOutLoopVarName(param.name()));
};

// Generated for: megVedLarested: [PersonProfil]
//   @service(service: ..., contextArguments: ["fnr", "tenantId"])
public CompletableFuture<List<PersonProfil>> megVedLarested(DataFetchingEnvironment env) {
    var ctx = graphitronContext(env);
    var executor = ctx.getExecutor(env);
    var fnr = (String) ctx.getContextArgument(env, "fnr");
    var elements = ctx.<String>getContextFanOut(env, "tenantId");

    var futures = elements.stream()
        .map(tenantId -> CompletableFuture.supplyAsync(() -> {
            DSLContext dsl = ctx.openContextDslContext(env, "tenantId", tenantId);
            try {
                return PersonService.getPersonVedLarested(dsl, fnr, tenantId);
            } catch (RuntimeException e) {
                return null;
            }
        }, executor))
        .toList();

    return CompletableFuture
        .allOf(futures.toArray(CompletableFuture[]::new))
        .thenApply(v -> futures.stream()
            .map(CompletableFuture::join)
            .filter(Objects::nonNull)
            .toList());
}