feat(types): array element covariance into a declared array<Object> parameter

[chadmandoo]

What

A PHP array parameter is a bare array — PHP does not enforce the @param array<T> element type at runtime, so the declared element type is a hint, not a hard bound. Two cases were rejected:

final class Builder {
    /** @param list<CondI> $conditions */
    public function __construct(private array $conditions) {}
    private function mkGroup(string $op): Group { return new Group($op); }
    public function addLeaf(Leaf $c): self {
        return $this->withConditions([...$this->conditions, $c]); // spread -> Array(Mixed)
    }
    public function addGroup(string $op): self {
        return $this->withConditions([$this->mkGroup($op)]);       // method-call element
    }
}

How

• types_compatible accepts Array(Mixed) (a spread literal or an adaptive local) and an element-compatible array in either covariance direction for a declared Array(T) param — mirroring the whole-value (_, Mixed) => true trust posture, one container level down.
• array_literal_element_type_for_ir types a method-call element as Mixed instead of the syntactic Int fallback. The old fallback stored an object-returning method's result in an Array(Int) and int-cast it at the element store (a hard backend error).

Test

test_array_element_covariance_spread_and_method_call — a fluent builder using both a spread element and a method-call element into an object-element array, byte-parity vs PHP 8.5.

🤖 Generated with Claude Code

[nahime0]

Closing as superseded

This PR is no longer needed on current main. The motivating fluent-builder scenario already compiles and runs correctly there (output G:AND|, matching PHP).

Why

Two later PRs landed the complete fix for the same surface:

1. fix(types): safely widen object elements for bare array parameters #519 — bare array parameters with object elements stay Array(Mixed) via specialize_generic_array_param_hint, so sibling/spread call sites are not checked against an Elephc-invented array<ConcreteObject> bound.
2. fix(ir-lower): type an indexed array-literal method-call element by the callee return #561 — array_literal_element_type_for_ir types method-call elements from the callee’s declared return type, instead of the syntactic Int fallback (and instead of stamping Mixed).

What this PR was

A two-part workaround, not the final model:

• Checker: bidirectional Array(T) / Array(U) acceptance in types_compatible — a global call-boundary relaxation, broader than the bare-array param case that actually needed fixing.
• IR: MethodCall / NullsafeMethodCall / StaticMethodCall → Mixed in array literals — avoids the int-cast backend error, but is coarser than typing by return type.

Cherry-picking this onto current main also leaves a dead duplicate MethodCall arm after #561 (unreachable_patterns warning), which conflicts with the zero-warnings policy.

Decision

Closing without merge. No rebase needed. If we still want the fluent-builder codegen test from this PR, it can be reintroduced on main as a pure test add — without the production hunks.