Context

This PR re-implements the functionality from PR #4248 ("OneOf Inhabitability" by @jbellenger) but based on the validation-refactor branch (PR #4228), since #4228 will be merged first.

PR #4248 targets master and adds validation for uninhabited OneOf input types. Since PR #4228 significantly refactors validation (consolidating 31 rule classes into a single OperationValidator, removing AbstractRule, RulesVisitor, and individual rule classes), the OneOf inhabitability changes need to be adapted to work with the new validation architecture.

What needs to be implemented

The core feature is validating that OneOf input types are "inhabited" — i.e., that a finite value can be constructed for them. A self-referential OneOf like input A @oneOf { a: A } is uninhabited because you can never construct a finite value for it.

This is based on the spec proposal at graphql/graphql-spec#1211

Changes needed (adapted from PR #4248 to the validation-refactor architecture):

1. src/main/java/graphql/schema/validation/SchemaValidationErrorType.java
Add a new enum value OneOfNotInhabited (between OneOfNonNullableField and RequiredInputFieldCannotBeDeprecated).

2. src/main/java/graphql/schema/validation/OneOfInputObjectRules.java
Add a new method visitGraphQLInputObjectType that checks if a OneOf input object type is inhabited. If not, it adds a SchemaValidationError with type OneOfNotInhabited.

Add the following logic (from PR #4248):

@Override
public TraversalControl visitGraphQLInputObjectType(GraphQLInputObjectType inputObjectType, TraverserContext<GraphQLSchemaElement> context) {
    if (!inputObjectType.isOneOf()) {
        return TraversalControl.CONTINUE;
    }
    SchemaValidationErrorCollector errorCollector = context.getVarFromParents(SchemaValidationErrorCollector.class);
    if (!canBeProvidedAFiniteValue(inputObjectType, new LinkedHashSet<>())) {
        String message = format("OneOf Input Object %s must be inhabited but all fields recursively reference only other OneOf Input Objects forming an unresolvable cycle.", inputObjectType.getName());
        errorCollector.addError(new SchemaValidationError(SchemaValidationErrorType.OneOfNotInhabited, message));
    }
    return TraversalControl.CONTINUE;
}

private boolean canBeProvidedAFiniteValue(GraphQLInputObjectType oneOfInputObject, Set<GraphQLInputObjectType> visited) {
    if (visited.contains(oneOfInputObject)) {
        return false;
    }
    Set<GraphQLInputObjectType> nextVisited = new LinkedHashSet<>(visited);
    nextVisited.add(oneOfInputObject);
    for (GraphQLInputObjectField field : oneOfInputObject.getFieldDefinitions()) {
        GraphQLType fieldType = field.getType();
        if (GraphQLTypeUtil.isList(fieldType)) {
            return true;
        }
        GraphQLUnmodifiedType namedFieldType = GraphQLTypeUtil.unwrapAll(fieldType);
        if (!(namedFieldType instanceof GraphQLInputObjectType)) {
            return true;
        }
        GraphQLInputObjectType inputFieldType = (GraphQLInputObjectType) namedFieldType;
        if (!inputFieldType.isOneOf()) {
            return true;
        }
        if (canBeProvidedAFiniteValue(inputFieldType, nextVisited)) {
            return true;
        }
    }
    return false;
}

New imports needed:

import graphql.schema.GraphQLType;
import graphql.schema.GraphQLUnmodifiedType;
import java.util.LinkedHashSet;
import java.util.Set;

3. src/test/groovy/graphql/schema/validation/OneOfInputObjectRulesTest.groovy
Add the following 10 test cases after the existing tests:

• "oneOf with scalar fields is inhabited" - input A @oneOf { a: String, b: Int } → no exception
• "oneOf with enum field is inhabited" - input A @oneOf { a: Color } with enum Color { RED GREEN BLUE } → no exception
• "oneOf with list field is inhabited" - input A @oneOf { a: [A] } → no exception
• "oneOf referencing non-oneOf input is inhabited" - input A @oneOf { a: RegularInput } with input RegularInput { x: String } → no exception
• "oneOf with escape field is inhabited" - input A @oneOf { b: B, escape: String } with input B @oneOf { a: A } → no exception
• "mutually referencing oneOf types with scalar escape is inhabited" - input A @oneOf { b: B } with input B @oneOf { a: A, escape: Int } → no exception
• "oneOf referencing non-oneOf with back-reference is inhabited" - input A @oneOf { b: RegularInput } with input RegularInput { back: A } → no exception
• "multiple fields with chained oneOf escape is inhabited" - input A @oneOf { b: B, c: C }, input B @oneOf { a: A }, input C @oneOf { a: A, escape: String } → no exception
• "single oneOf self-reference cycle is not inhabited" - input A @oneOf { self: A } → InvalidSchemaException with 1 error of type OneOfNotInhabited
• "multiple oneOf types forming cycle are not inhabited" - input A @oneOf { b: B }, `input B @oneo...