feat: add pipe assignment operator (|>=)

Adds the `|>=` compound assignment operator for the pipe operator,
allowing `$x |>= callable` to be used as shorthand for `$x = $x |> callable`.

Supports pipe chains on the RHS:
`$x |>= fn1(...) |> fn2(...) |> fn3(...)`
is equivalent to
`$x = $x |> fn1(...) |> fn2(...) |> fn3(...)`.

Implementation modeled after `??=` (ZEND_AST_ASSIGN_COALESCE), with a
dedicated AST node (ZEND_AST_ASSIGN_PIPE) and compiler function that
uses memoization to avoid double-evaluating complex LHS expressions.

Extracts shared callable dispatch logic into zend_pipe_build_fcall()
helper used by both `|>` and `|>=` compilation.

All variable target types supported: simple vars, array dims, object
properties, static properties.

Author: calebdw

Zend/tests/pipe_operator/assign_pipe_001.phpt

@@ -0,0 +1,12 @@
+--TEST--
+Pipe assign operator basic usage with first-class callable
+--FILE--
+<?php
+
+$x = "hello";
+$x |>= strtoupper(...);
+var_dump($x);
+
+?>
+--EXPECT--
+string(5) "HELLO"

Zend/tests/pipe_operator/assign_pipe_002.phpt

@@ -0,0 +1,29 @@
+--TEST--
+Pipe assign operator with closures and arrow functions
+--FILE--
+<?php
+
+$x = 5;
+$x |>= (fn($v) => $v * 2);
+var_dump($x);
+
+$y = "hello world";
+$y |>= (function($s) { return strtoupper($s); });
+var_dump($y);
+
+$arr = [5, 2, 8, 1, 9];
+$arr |>= (fn($a) => array_filter($a, fn($n) => $n > 3));
+var_dump($arr);
+
+?>
+--EXPECT--
+int(10)
+string(11) "HELLO WORLD"
+array(3) {
+  [0]=>
+  int(5)
+  [2]=>
+  int(8)
+  [4]=>
+  int(9)
+}

Zend/tests/pipe_operator/assign_pipe_003.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Pipe assign operator chain support (multiple |> on RHS)
+--FILE--
+<?php
+
+$val = 10;
+$val |>= (fn($v) => $v * 2) |> (fn($v) => $v + 3) |> (fn($v) => $v * $v);
+var_dump($val);
+
+$data = "  the quick brown FOX  ";
+$data |>= trim(...)
+    |> strtolower(...)
+    |> (fn($s) => explode(" ", $s))
+    |> (fn($a) => array_map(ucfirst(...), $a))
+    |> (fn($a) => implode("-", $a));
+var_dump($data);
+
+?>
+--EXPECT--
+int(529)
+string(19) "The-Quick-Brown-Fox"

Zend/tests/pipe_operator/assign_pipe_004.phpt

@@ -0,0 +1,35 @@
+--TEST--
+Pipe assign operator with all variable target types
+--FILE--
+<?php
+
+$x = "hello";
+$x |>= strtoupper(...);
+var_dump($x);
+
+$data = ["key" => "hello"];
+$data["key"] |>= strtoupper(...);
+var_dump($data["key"]);
+
+$nested = ["a" => ["b" => "hello"]];
+$nested["a"]["b"] |>= strtoupper(...);
+var_dump($nested["a"]["b"]);
+
+$obj = new stdClass;
+$obj->name = "hello";
+$obj->name |>= strtoupper(...);
+var_dump($obj->name);
+
+class Foo {
+    public static string $val = "hello";
+}
+Foo::$val |>= strtoupper(...);
+var_dump(Foo::$val);
+
+?>
+--EXPECT--
+string(5) "HELLO"
+string(5) "HELLO"
+string(5) "HELLO"
+string(5) "HELLO"
+string(5) "HELLO"

Zend/tests/pipe_operator/assign_pipe_005.phpt

@@ -0,0 +1,27 @@
+--TEST--
+Pipe assign operator single-evaluation semantics
+--FILE--
+<?php
+
+$counter = 0;
+function track(): int {
+    global $counter;
+    $counter++;
+    echo "track() called (call #", $counter, ")", PHP_EOL;
+    return 0;
+}
+
+$arr = ["hello"];
+$arr[track()] |>= strtoupper(...);
+
+echo "track() was called ", $counter, " time(s)", PHP_EOL;
+var_dump($arr);
+
+?>
+--EXPECT--
+track() called (call #1)
+track() was called 1 time(s)
+array(1) {
+  [0]=>
+  string(5) "HELLO"
+}

Zend/tests/pipe_operator/assign_pipe_006.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Pipe assign operator error: unparenthesized arrow function
+--FILE--
+<?php
+
+$x = 5;
+$x |>= fn($v) => $v * 2;
+
+?>
+--EXPECTF--
+Fatal error: Arrow functions on the right hand side of |>= must be parenthesized in %s on line %d

Zend/tests/pipe_operator/assign_pipe_007.phpt

@@ -0,0 +1,14 @@
+--TEST--
+Pipe assign operator error: cannot reassign $this
+--FILE--
+<?php
+
+class Bar {
+    public function test() {
+        $this |>= trim(...);
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot re-assign $this in %s on line %d

Zend/tests/pipe_operator/assign_pipe_008.phpt

@@ -0,0 +1,23 @@
+--TEST--
+Pipe assign operator error: by-reference rejection
+--FILE--
+<?php
+
+function modify_ref(int &$a): int {
+    $a += 1;
+    return $a;
+}
+
+try {
+    $a = 5;
+    $a |>= modify_ref(...);
+} catch (\Error $e) {
+    echo $e::class, ": ", $e->getMessage(), PHP_EOL;
+}
+
+var_dump($a);
+
+?>
+--EXPECTF--
+Error: modify_ref(): Argument #1 ($a) could not be passed by reference
+int(5)

Zend/tests/pipe_operator/assign_pipe_009.phpt

@@ -0,0 +1,41 @@
+--TEST--
+Pipe assign operator expression result and precedence
+--FILE--
+<?php
+
+function triple(int $x): int { return $x * 3; }
+function add_five(int $x): int { return $x + 5; }
+function to_string(int $x): string { return "value:$x"; }
+
+$x = 5;
+$result = ($x |>= triple(...));
+var_dump($x, $result);
+
+$e = 4;
+$f = ($e |>= triple(...)) |> add_five(...) |> to_string(...);
+var_dump($e, $f);
+
+// Right-associativity
+// Parses as: $foo |>= ($bar |>= x(...))
+// 1. $bar |>= x(...) calls x(0), which prints int(0) and returns a Closure
+// 2. $bar is assigned the Closure
+// 3. $foo |>= <Closure> calls Closure(1) = 2
+// 4. $foo is assigned 2
+function x(int $bar): Closure {
+    var_dump($bar);
+    return function (int $foo): int { return $foo + 1; };
+}
+$bar = 0;
+$foo = 1;
+$foo |>= $bar |>= x(...);
+var_dump($bar instanceof Closure, $foo);
+
+?>
+--EXPECT--
+int(15)
+int(15)
+int(12)
+string(8) "value:17"
+int(0)
+bool(true)
+int(2)

Zend/tests/pipe_operator/assign_pipe_010.phpt

@@ -0,0 +1,47 @@
+--TEST--
+Pipe assign operator with mixed callable types
+--FILE--
+<?php
+
+function double(int $x): int { return $x * 2; }
+
+class Math {
+    public function triple(int $x): int { return $x * 3; }
+    public static function quadruple(int $x): int { return $x * 4; }
+}
+
+$math = new Math();
+
+$v1 = 5;
+$v1 |>= double(...);
+var_dump($v1);
+
+$v2 = 5;
+$v2 |>= $math->triple(...);
+var_dump($v2);
+
+$v3 = 5;
+$v3 |>= Math::quadruple(...);
+var_dump($v3);
+
+class Multiplier {
+    public function __construct(private int $factor) {}
+    public function __invoke(int $x): int { return $x * $this->factor; }
+}
+
+$v4 = 5;
+$v4 |>= new Multiplier(10);
+var_dump($v4);
+
+$times6 = fn($x) => $x * 6;
+$v5 = 5;
+$v5 |>= $times6;
+var_dump($v5);
+
+?>
+--EXPECT--
+int(10)
+int(15)
+int(20)
+int(50)
+int(30)