Skip constant-array guards when creating conditional expressions for subtype-absorbed targets

- In MutatingScope::createConditionalExpressions(), a subtype-absorbed
  variable is kept as a conditional-expression *target* (since #5876) so it
  can be re-narrowed when its guard is re-asserted. Pairing such a target with
  a constant-array guard, however, never re-narrows anything: a constant array
  represents a unique literal value that is not re-asserted as a condition
  later. Those conditional expressions were pure cost — the downstream
  isSuperTypeOf() guard machinery (including the reverse check added in #5848)
  compared these potentially huge constant arrays on every branch merge during
  loop convergence.
- Skip creating a conditional expression for a subtype-absorbed target when the
  guard's type is a constant array, avoiding both the holder creation and the
  expensive guard-selection comparisons.
- Recovers the ~15% analysis-time regression on constant-array-heavy loop code
  (tests/bench/data/bug-10538.php) while preserving the #5876 inference
  improvement (bug-7948, bug-11281 remain green).
- Verified the removed conditional expressions never produced a re-narrowing
  (a constant-array-guarded absorbed target already inferred the widened type
  both before and after the change), so behavior is unchanged — all 1671
  NodeScopeResolver inference tests pass identically.
- Probed broadening the skip to all targets (not just subtype-absorbed ones):
  it recovers even more time but breaks a legitimate re-narrowing that relies
  on a constant-array guard, so the skip is scoped to subtype-absorbed targets.

Author: ondrejmirtes

src/Analyser/MutatingScope.php

@@ -3927,7 +3927,17 @@ private function createConditionalExpressions(
 				continue;
 			}
 
+			$exprIsGuardExcluded = array_key_exists($exprString, $guardsToExclude);
 			foreach ($variableTypeGuards as $guardExprString => $guardHolder) {
+				// A subtype-absorbed target (kept only for re-narrowing) paired with a
+				// constant-array guard never helps: such a guard represents a unique
+				// literal value that is not re-asserted as a condition later, yet the
+				// downstream isSuperTypeOf() guard machinery pays to compare these
+				// (potentially huge) constant arrays on every branch merge. Skip them.
+				if ($exprIsGuardExcluded && $guardHolder->getType()->isConstantArray()->yes()) {
+					continue;
+				}
+
 				if (
 					array_key_exists($guardExprString, $theirExpressionTypes)
 					&& $theirExpressionTypes[$guardExprString]->getCertainty()->yes()