[EarlyReturn] Split nested && operand into its own early return in ReturnBinaryOrToEarlyReturnRector

[TomasVotruba]

Fixes rectorphp/rector#9802

ReturnBinaryOrToEarlyReturnRector silently dropped operands when a returned || chain contained a parenthesized && in a nested-left position.

Problem

The rule used an empty array [] as an abort signal when it met a && operand. But when the && sat deep in the left branch of a longer || chain, that [] was spread back into the collected ifs during recursion — indistinguishable from "nothing collected here" — so collection resumed and the earlier operands were discarded:

 public function hasStale(): bool
 {
-    return $this->donation === null
-        || ($this->commission > 0 && $this->transaction === null)
-        || $this->somethingElse()
-        || $this->anotherThing();
+    if ($this->somethingElse()) {
+        return true;
+    }
+    return $this->anotherThing();
 }

The first two operands ($this->donation === null and the && group) vanished — the method no longer meant the same thing.

Fix

A && operand is a perfectly valid early-return condition, so instead of skipping it is now kept whole inside its own if. The convoluted recursive createMultipleIfs/collectLeftBooleanOrToIfs pair (and its ambiguous [] abort) is replaced by a simple flatten of the left-associative || chain into ordered operands — each becomes one early return, the last becomes the final return.

 public function hasStale(): bool
 {
-    return $this->donation === null
-        || ($this->commission > 0 && $this->transaction === null)
-        || $this->somethingElse()
-        || $this->anotherThing();
+    if ($this->donation === null) {
+        return true;
+    }
+    if ($this->commission > 0 && $this->transaction === null) {
+        return true;
+    }
+    if ($this->somethingElse()) {
+        return true;
+    }
+    return (bool) $this->anotherThing();
 }

Tests

• Added and_nested_deep.php.inc (the reported case).
• The former skip_and_in_next.php.inc is now and_in_next.php.inc — a && in the middle of a chain now transforms instead of being skipped.
• All existing fixtures still pass unchanged.