Cache per-guard isSuperTypeOf() results in createConditionalExpressions() instead of recomputing them per target

- Both the forward (`guard`-supertype-of-`their`) and reverse (`their`-supertype-of-`guard`) `isSuperTypeOf()` checks in the guard-selection loop depend only on the guard expression, not on the target `$exprString` being iterated. They were recomputed once per (target, guard) pair, an O(N*M) redundancy that is very expensive on big union / constant-array types.
- Cache both results per `$guardExprString` in local arrays, so each pair of supertype checks runs at most once per guard per branch merge.
- Keep the reverse check (added in #5848 for the enum-guard false positive fixed by bug-14807) as the last operand of the OR so it is only computed when the cheaper forward-based conditions did not already decide — it is now also memoized.
- This neutralizes both the #5848 reverse-check cost and the #5876 target-count amplification that compounded in the same machinery: bug-14462.php ~-31%, bug-10538.php ~-21% locally, while all analysis output (including bug-14807) is unchanged.

Author: ondrejmirtes

src/Analyser/MutatingScope.php

@@ -3901,6 +3901,14 @@ private function createConditionalExpressions(
 			return $conditionalExpressions;
 		}
 
+		// Both isSuperTypeOf() checks below depend only on the guard (and its
+		// their-branch type), not on the target $exprString, so their results are
+		// invariant across the target loop. Cache them per guard to avoid
+		// recomputing expensive supertype checks on big union / constant-array
+		// types once per (target, guard) pair.
+		$guardIsSuperTypeOfTheirExprCache = [];
+		$theirExprIsSuperTypeOfGuardCache = [];
+
 		foreach ($newVariableTypes as $exprString => $holder) {
 			if ($holder->getExpr() instanceof VirtualNode) {
 				continue;
@@ -3924,12 +3932,13 @@ private function createConditionalExpressions(
 					array_key_exists($guardExprString, $theirExpressionTypes)
 					&& $theirExpressionTypes[$guardExprString]->getCertainty()->yes()
 				) {
-					$guardIsSuperTypeOfTheirExpr = $guardHolder->getType()->isSuperTypeOf($theirExpressionTypes[$guardExprString]->getType());
-					$theirExprIsSuperTypeOfGuard = $theirExpressionTypes[$guardExprString]->getType()->isSuperTypeOf($guardHolder->getType());
+					$guardIsSuperTypeOfTheirExpr = $guardIsSuperTypeOfTheirExprCache[$guardExprString] ??= $guardHolder->getType()->isSuperTypeOf($theirExpressionTypes[$guardExprString]->getType());
 
+					// The reverse isSuperTypeOf() check is expensive on big union /
+					// constant-array types, so it is evaluated last and only when the
+					// cheaper forward-based conditions did not already decide.
 					if (
 						$guardIsSuperTypeOfTheirExpr->yes()
-						|| $theirExprIsSuperTypeOfGuard->yes()
 						|| (
 							array_key_exists($exprString, $theirExpressionTypes)
 							&& $theirExpressionTypes[$exprString]->getCertainty()->yes()
@@ -3940,6 +3949,7 @@ private function createConditionalExpressions(
 							&& $holder->getType()->equals($guardHolder->getType())
 							&& !$guardIsSuperTypeOfTheirExpr->no()
 						)
+						|| ($theirExprIsSuperTypeOfGuardCache[$guardExprString] ??= $theirExpressionTypes[$guardExprString]->getType()->isSuperTypeOf($guardHolder->getType()))->yes()
 					) {
 						continue;
 					}