feat(code-action): convert arrow function to closure

Add a refactor.rewrite code action that converts arrow functions to
anonymous closures: `fn($x) => $x * 2` becomes
`function($x) { return $x * 2; }`.

Variables from the outer scope used in the expression are automatically
detected and captured via a `use()` clause. `$this` is excluded since
closures bind it automatically (unless static). Nested arrow functions
are handled by extending the parameter exclusion set.

Preserves:
- static keyword
- Return type hints
- Parameter type hints

Includes 10 unit tests covering: simple expressions, type hints,
static arrows, single/multiple variable capture, $this exclusion,
parameter exclusion, method calls with captures, and deduplication.

Closes #148

Author: calebdw

docs/CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Static methods complete on instance access.** Member completion after `->` now offers a class's static methods alongside its instance methods, since PHP lets you call a static method through an instance (`$obj->make()`). Static properties remain excluded, as they are only reachable via `::`. Contributed by @calebdw in https://github.com/AJenbo/phpantom_lsp/pull/174.
 - **Array-callable navigation.** Method-name strings in array callables — `[Controller::class, 'method']` and `[$object, 'method']` — now resolve like a real member reference. This makes go-to-definition, find-references, and rename work on Laravel controller actions such as `Route::get('/', [IndexPageController::class, 'indexPage'])`.
 - **Array-callable method completion.** Typing inside the method-name string of an array callable (`[Controller::class, '|']`) now offers method name completions from the resolved class, including inherited and trait methods. Works with `Class::class` constants, `$this`, and typed variables. (thanks @calebdw)
+- **Convert arrow function to closure.** A new `refactor.rewrite` code action converts arrow functions to anonymous closures (`fn($x) => $x * 2` to `function($x) { return $x * 2; }`). Variables from the outer scope are automatically captured via a `use()` clause. Preserves `static` and return type hints. (contributed by @calebdw)
 - **Magic methods complete when implemented.** Magic methods declared on a class (`__invoke`, `__toString`, `__call`, and the rest) are now offered in member completion, so explicit calls like `$x->__invoke()` autocomplete and support go-to-definition. They are sorted below the regular methods so they never appear at the top of the list.
 - **Staleness detection and auto-refresh.** The class index, function index, and constant index now stay fresh automatically. When PHP files are created or deleted outside the editor (e.g. `git checkout`, code generation), the indices update without a restart, and edits made outside the editor are reflected the next time the file is used. When `composer.json` or `composer.lock` changes (e.g. after `composer install`), vendor packages are rescanned automatically.
 - **`#[ArrayShape]` attribute support.** Functions and methods annotated with `#[ArrayShape(["key" => "type", ...])]` (used by ~84 phpstorm-stubs entries) now produce array shape key completions, hover type info, and correct type resolution. Affects commonly used functions like `parse_url`, `stat`, `pathinfo`, `gc_status`, `getimagesize`, and `session_get_cookie_params`.

examples/demo.php

@@ -3585,6 +3585,30 @@ public function demo(): void
     }
 }
 
+class ConvertToClosureDemo
+{
+    public function demo(): void
+    {
+        // Try: place cursor on `fn` and use code action "Convert to closure"
+        $double = fn(int $x): int => $x * 2;
+
+        // Arrow with captured outer variable — converted closure gets use()
+        $base = 10;
+        $add = fn(int $x) => $x + $base;
+
+        // Static arrow function
+        $staticFn = static fn(string $s): string => strtoupper($s);
+
+        // Arrow as callback — trigger inside the arrow function
+        $result = array_map(fn(string $s) => strtoupper($s), ['a', 'b']);
+
+        // Multiple captured variables
+        $prefix = 'hello';
+        $suffix = 'world';
+        $greet = fn(string $sep) => $prefix . $sep . $suffix;
+    }
+}
+
 // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
 // ┃  SCAFFOLDING — Supporting definitions below this line.              ┃