Adds comprehensive test coverage for issue #3096:
- Test that compatible interface field overrides are allowed
- Test that incompatible overrides still error
- Test that non-interface duplicates still error (preserves existing behavior)
- Test that type modifiers (non_null, list_of) work correctly

These tests will initially fail until the fix is implemented.

Fixes PHPCS PSR2.Files.EndFileNewline.NoneFound error

Add tests that verify interface field overrides work correctly when
overriding with the same type (e.g., Post.field with type Post).

These tests will fail without the fix, demonstrating the bug.
Tests cover:
- Dovid's exact scenario (both register_graphql_field and filter)
- Multiple interfaces
- Page type (not just Post)
- Custom post types
- Filter-only approach

Related to #3540

- Fix variable alignment issues
- Fix PHPStan null coalescing issue by using explicit empty check
- Fix else/if structure to use elseif
- Fix indentation issues

…w-compatible-interface-field-override

…interface-field-override

Expose the monorepo phpcs directory inside wp-env so plugin lint scripts can resolve shared WPGraphQL sniffs in containerized runs.

Add regression tests for unregistered and non-object override types so duplicate-field compatibility guards remain covered and future refactors don't reopen this behavior.

Add regression tests for loaded and loader-backed interface name resolution paths plus guard behavior for non-interface and empty type-name string scenarios.

…override

When the compat check resolves the override's target type via get_type, the
graphql_get_type filter runs InstrumentSchema which re-enters the
graphql_{Type}_fields filter chain while the outer compat call is still
in-flight. Each callback in the re-entered chain then hit the
checking_compatibility recursion guard, returned false, and logged a
spurious DUPLICATE_FIELD entry even though the outer pass had already
accepted the override. Guard the duplicate-field branch with a fast no-op
when checking_compatibility is set so the outer decision is preserved
without debug noise.

Also broaden the override compatibility check to a second path: when the
existing field's type is a concrete/scalar but the field itself came from
an implemented interface, look up the interface's declared field type via
the implementing ObjectType and accept the override if the wrapping
structure matches and the override's base type is either identical or a
concrete implementation of the interface's base type. This covers
same-type resolver overrides (e.g. Post.related: Post inherited from a
HasSelfRef interface) without loosening protection for unrelated duplicate
registrations.

The register_field filter callback now receives the WPObjectType instance
(filter accepted-args bumped to 2) so the inherited-field lookup can read
implemented interfaces without round-tripping through get_type.

Squiz.Commenting.FunctionComment.SpacingAfterParamType requires the
variable column to align based on the longest parameter type. The
docblocks for is_compatible_interface_field_override and
is_override_compatible_with_interface_field_type added in the previous
commit had a few extra padding spaces, tripping phpcs in CI.

Adds 4 wpunit tests exercising the inherited-field (Path 2) compatibility
branches that were uncovered by patch coverage:

- testCompatibleInterfaceFieldOverrideWithListOfScalar: drives the
  list_of branch through unwrap_field_type_config and
  unwrap_field_type_instance.
- testCompatibleInterfaceFieldOverrideWithNonNullScalar: drives the
  non_null branch through both unwrap helpers.
- testIncompatibleInterfaceFieldOverrideWithMismatchedWrappersStillErrors:
  covers wrapper-mismatch rejection (interface declares list_of String,
  override declares non_null String).
- testCompatibleInterfaceFieldOverrideWhereInheritedFieldTypeIsInterface:
  covers the inherited-interface-typed-field path through
  resolve_interface_name_from_type_name + type_implements_interface.

…fety

Adds four short subsections to interfaces.md so extension authors know
exactly what overrides are accepted by the new compatibility check:

- "Compatible Override Rules": wrappers must match exactly; base type
  must equal the interface's base or implement it.
- "Narrowing Wrapped Interface Field Types": list_of/non_null example
  mirroring the downstream use case from the PR (and the new wpunit
  coverage).
- "Same-Type Overrides": notes the recursion-safe handling that fixes
  issue #3540, with a Post.related example.
- "Behavioral Change Note": flags that previously permissive duplicate
  overrides may now consistently emit DUPLICATE_FIELD when not
  verifiably compatible, framed as a correctness fix.