fix(preprocessor): enforce Zend enum declaration rules

[AlessioGiacobbe]

Enum declaration rules were entirely unenforced — all of these compiled (each a Zend compile fatal, probed for the exact rule and message): properties in enums; the forbidden magic-method set (__construct, __destruct, __clone, __get/__set/__unset/__isset, __sleep/__wakeup, __set_state, __serialize/__unserialize, __toString, __debugInfo — the full set probed one by one; __call/__callStatic/__invoke stay legal); a case with a value in a non-backed enum and a case without one in a backed enum; duplicate case names and case/const clashes; backing types other than int|string; explicit implements UnitEnum/BackedEnum; abstract methods in enum bodies.

Enum ClassDef flags now also carry FINAL (mirroring ZEND_ACC_FINAL on enum class entries), so class B extends SomeEnum is rejected by the existing final-class check with Zend's own wording, and final-class devirtualization legitimately applies to enums.

Deliberately not added, because Zend evaluates them lazily at runtime: case-value/backing-type mismatches and duplicate case values.

Part of the split of #39.

[matyhtf]

Two enum paths are still outside these checks.

1. Forbidden magic methods introduced by a trait are accepted because the new check only runs in prepareClassMethod(). Composed and aliased trait methods are installed through installComposedTraitMethod():

trait T { public function __construct() {} }
enum Suit { use T; case Hearts; }

Zend reports Enum Suit cannot include magic method __construct; this PR dry-compiles it. Centralize the enum magic-method check and call it for composed/aliased methods as well. Add at least a trait-injected __construct test (an alias renamed to a forbidden magic name should follow the same path).

2. Backed enum case values are not limited to scalar literal nodes. case Two = 1 + 1 and constant references are valid PHP, but this code still reads $v->expr?->value during prepare:

enum Number: int { case Two = 1 + 1; }
function main(): void { var_dump(Number::Two->value); }

TypePHP emits Undefined property: BinaryOp\Plus::$value, records null, and later resolves the backed case as the string case name instead of integer 2. Preserve the expression AST in prepare and evaluate it in the convert phase using the existing constant-expression machinery; do not assume a scalar node or evaluate implementation expressions during prepare. Add runtime coverage for an arithmetic expression and a constant reference.

[AlessioGiacobbe]

Both paths closed, rebased on current master:

1. Trait-composed magic methods — the ban is centralized in assertEnumMayIncludeMethod() and now also runs where composed/aliased trait methods are installed, which sees post-adaptation names: both a trait-declared __construct and use T { foo as __construct; } fail with Zend's message ("Enum Suit cannot include magic method __construct"). Tests for both shapes.

2. Non-literal backed case values — prepare now stores scalar literals directly and keeps any other expression as its AST (no evaluation during prepare, no Throwable catching, no null overloading); the constant machinery evaluates it lazily on first convert-phase access and memoizes. Plain constant references resolve too, so const TWO = 2; case Two = TWO; works. Number::Two->value folds to int(2) instead of the case-name string, and the registration emits ZVAL_LONG(..., 2) (it always had the correct value — the compile-time folder was the broken half). Runtime PHPT covers arithmetic, constant references, a constant product, string concat, ->name, and from(), with Zend-validated expectations.

The rebase also surfaced a pleasant interaction: upstream's abstract-method checks now fire before the enum complaint for abstract private function in enums, matching Zend's diagnostic order (probed).

[matyhtf]

Please rebase this branch onto the latest master; #45, #52, #59, #63, and #66 have now been merged.

Two constant-expression paths still need correction.

1. enumCaseExprs is unset only after evaluation succeeds, but there is no in-progress/visiting guard. Accessing a self-referencing case such as enum E: int { case A = E::A; } recursively enters getClassConstValue() until the compiler exhausts the stack/memory. Zend reports Cannot declare self-referencing constant E::A. Mutual cycles need the same protection.
2. Lazy evaluation can run while the translator is converting a different namespace. getClassConstValue() currently prefers $this->namespace, and the class-constant callback reduces Name\FullyQualified to a string, so an enum expression declared in namespace A may be resolved relative to namespace B when first referenced there.

Please add an evaluation stack keyed by the declaring enum/case, preserve the AST until successful completion, and resolve names using the expression declaration context/resolved AST name rather than the current conversion namespace. Add self-cycle, mutual-cycle, and cross-file/cross-namespace tests.

[AlessioGiacobbe]

Rebased onto current master. Both paths fixed:

1. Cycle guard — lazy evaluation now runs inside an in-progress set keyed by Enum\Fqn::CaseName; re-entry emits Cannot declare self-referencing constant \E::A`, and the AST stays in place until an evaluation completes successfully (popped in a finally). Probed against Zend 8.4.13 to match the reported constant exactly: E::Aforcase A = E::A;, E::Bfor the mutual paircase A = E::B; case B = E::A;` regardless of which case is accessed, and likewise for a 3-cycle.
2. Declaration-context resolution — the class-constant callback now prefers the resolved AST name (resolvedName attribute / the node's fully qualified form), passed with a leading backslash so the active conversion namespace can never be prepended on top; and the preprocessor captures the declaring file's use-imports into ClassDef::$enumUse* (mirroring the existing traitUse* pattern), with evaluation running inside withDeclarationNameContext() — factored out of withTraitNameContext(), which now delegates to it.

Tests: self-cycle and mutual-cycle fatals with the exact messages, plus cross-namespace (with a decoy same-name symbol in the referencing namespace) and cross-file positives asserting the generated case/constant values, with the referencing file converted first.