Fix: internal interfaces should not prevent class/enum early binding

[AJenbo]

Problem

Implementing an internal interface prevents the compiler from hoisting (early binding) a class or enum, breaking forward references that would otherwise work:

// Works
class B extends A {}
class A {}

// Fatal error: Class "A" not found
class B extends A {}
class A {
    public function __toString(): string { return ''; }
}

// Same problem with explicit Stringable
class B extends A {}
abstract class A implements Stringable {}

// Same problem with other internal interfaces
class B extends A {}
class A implements Countable {
    public function count(): int { return 0; }
}

// Same problem with enums (implicit UnitEnum)
echo Suit::Hearts->name;
enum Suit { case Hearts; }

Previously reported as #7873, #8323, and #19729, all closed as won't fix.

Root cause

The early binding guard in zend_compile_class_decl() checks !ce->num_interfaces and skips hoisting when any interfaces are present:

/* We currently don't early-bind classes that implement interfaces or use traits */
if (!ce->num_interfaces && !ce->num_traits && ...) {

This makes sense for userland interfaces that may not exist yet at compile time, but internal interfaces like Stringable, Countable, ArrayAccess, Iterator, IteratorAggregate, Traversable, UnitEnum, and BackedEnum are registered during engine startup and are always available.

The most common triggers:

• __toString(): add_stringable_interface() implicitly adds Stringable during compilation
• Enums: zend_enum_add_interfaces() implicitly adds UnitEnum (and BackedEnum)
• Any explicit implements of a built-in interface

Fix

Zend/zend_compile.c:

• New zend_can_early_bind_interfaces() uses an allowlist of known-safe core interfaces rather than allowing all internal interfaces. Some internal interfaces have interface_gets_implemented callbacks that trigger fatal errors or user-observable side effects at compile time (e.g. DateTimeInterface errors for user classes, Throwable errors for non-Exception/Error classes, Serializable triggers E_DEPRECATED via the user error handler). Only interfaces without a callback (Stringable, Countable) or with known-safe callbacks (ArrayAccess, Iterator, IteratorAggregate, Traversable, UnitEnum, BackedEnum) are allowed.
• zend_inheritance_check_override() moved after interface resolution so #[\Override] works correctly with interface methods.
• Enums get zend_enum_register_funcs() (registers cases(), from(), tryFrom()) and zend_verify_enum() in the early binding path, matching what zend_do_link_class() does.

Zend/zend_inheritance.c:

• New zend_early_bind_resolve_internal_interfaces() for the no-parent early binding path. Uses zend_do_implement_interfaces() (same function zend_do_link_class() uses) for correct deduplication of overlapping interface hierarchies (e.g. a class implementing both RecursiveIterator and Iterator).
• zend_try_early_bind() extended to handle classes that have their own unresolved interfaces when early binding with a parent, combining them with parent interfaces via zend_do_implement_interfaces(). Also builds the traits_and_interfaces array for opcache's inheritance cache functions, which previously received NULL since num_interfaces was always 0 in the early-bind path.

Tests

New test Zend/tests/early_binding_internal_interfaces.phpt covers:

• Implicit Stringable (from __toString())
• Explicit implements Stringable
• Countable, ArrayAccess, IteratorAggregate
• Multiple internal interfaces combined
• Abstract parent with Stringable, child with __toString()
• Both parent and child having __toString()
• String casting through inheritance
• Unit enum hoisting with cases()
• Backed enum hoisting with from() and tryFrom()