Generalize empty-array accessory filter via accepts()

Vincent's review on #5568 raised that the explicit
`OversizedArrayType` / `NonEmptyArrayType` filter is too narrow — the
same `array{} & accessory` contradiction could in principle arise with
any accessory whose `accepts(array{})` is `no` (e.g. `HasOffsetType`).

Switch the predicate to `!$accessory->accepts(emptyArray, true)->no()`
so future accessories don't reintroduce the bug.

Notes from the audit:

- `OversizedArrayType::isIterableAtLeastOnce()` returns `maybe`
  (relaxed by 8d87c67, "Solve 11703" — an oversized-tagged array
  built via conditional pushes can be empty), so the more obvious
  `$accessory->isIterableAtLeastOnce()->yes()` predicate would NOT
  catch oversized. The `accepts(array{})` predicate is the correct
  one because the bug surfaces via accepts-based supertype checks.

- Today only `OversizedArrayType` actually leaks into the common
  accessory set via partial presence — `NonEmptyArrayType`,
  `HasOffsetType`, `HasOffsetValueType`, `AccessoryArrayListType`
  are added to the common set only when ALL inputs carry them, so
  no empty input can reach the intersection. The general predicate
  is forward-defensive, not currently load-bearing for the other
  accessories.

- There is also an internal inconsistency in `OversizedArrayType`
  itself: `accepts()` still uses `isIterableAtLeastOnce()->yes()`
  while `isIterableAtLeastOnce()` returns `maybe`. That's tracked
  as a separate concern in phpstan/phpstan#14560 and is out of
  scope here.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: gnutix

src/Type/TypeCombinator.php

@@ -960,16 +960,22 @@ private static function processArrayTypes(array $arrayTypes): array
 		}
 
 		$reducedArrayTypes = self::optimizeConstantArrays(self::reduceArrays($arrayTypes, true));
+		$emptyArrayType = null;
 		foreach ($reducedArrayTypes as $idx => $reducedArray) {
 			$applied = $accessoryTypes;
 			if ($reducedArray->isIterableAtLeastOnce()->no()) {
-				// Empty arrays cannot satisfy non-empty / oversized constraints —
-				// applying those accessories would produce a contradictory intersection
-				// (e.g. `array{}&oversized-array`) that rejects the very value it
-				// represents, breaking the super-type contract of the union.
+				// Filter accessories that reject empty arrays — applying them
+				// would build a contradictory intersection (e.g.
+				// `array{}&oversized-array`, `array{}&hasOffset('foo')`) that
+				// rejects the very value it represents, breaking the super-type
+				// contract of the union. Today only `OversizedArrayType` can
+				// leak here via the partial-presence special case in
+				// `processArrayAccessoryTypes`; the predicate is general so
+				// that future accessories don't reintroduce the bug.
+				$emptyArrayType ??= new ConstantArrayType([], []);
 				$applied = array_values(array_filter(
 					$applied,
-					static fn (Type $t): bool => !($t instanceof OversizedArrayType) && !($t instanceof NonEmptyArrayType),
+					static fn (Type $t): bool => !$t->accepts($emptyArrayType, true)->no(),
 				));
 			}
 			$reducedArrayTypes[$idx] = self::intersect($reducedArray, ...$applied);