feat(plugin): activate plugins through the PHP RPC worker

Implement the remainder of PluginManager::registerPackage: the plugin
autoload map is built by the ported createLoader/parseAutoloads and
served to the worker over the existing reverse-RPC autoloader, files
entries go through a composerRequire-equivalent glue call, and
already-defined classes take the upstream _composer_tmp rename/eval
path. Instantiation uses the new NewObject/CallPhpMethod lanes backed
by a P table in the worker; PhpPluginProxy adapts the resulting handle
to PluginInterface, with $composer/$io exposed to plugin callbacks via
an R table (unsupported methods stay explicit errors). Hand-written
proxy stubs cover Composer, PartialComposer and the IO hierarchy, and
the stub autoloader is re-prepended after loading the Composer PHP
runtime so its vendor autoloader cannot shadow proxied FQCNs.

FilesystemRepository::write now mirrors InstalledVersions::reload into
a running worker (class_exists-guarded, so an unloaded class keeps its
upstream lazy-load behavior), removing the previously undefined
observation window.

The installer pipeline passes the installed repository as a shared
handle instead of a long-lived `&mut dyn`: plugin registration runs
inside InstallationManager::execute and re-enters the same local
repository through the RepositoryManager, which would panic on the
RefCell re-borrow under the old shape.

PluginInterface lifecycle methods now take an owned ComposerHandle
(plugins retain $composer past the call) and return anyhow::Result
(PHP plugin code may throw); the plugin list uses shared ownership so
the identity comparison of removePlugin survives the dual storage in
registeredPlugins, matching PHP reference semantics.

Ports the activate/upgrade/uninstall tests of PluginInstallerTest,
serialized across the shared worker process whose persistent class
table is exactly what exercises the rename path.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

1 files changed, 113 insertions, 0 deletions

diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php b/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php
new file mode 100644
index 00000000..7f085178
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php
@@ -0,0 +1,113 @@
+<?php
+
+// Hand-written proxy stub for Composer\PartialComposer, kept in the shape the future stub
+// generator will output: the real public methods, each forwarding to the Rust-side entity.
+// Methods the Rust dispatcher does not support yet surface as explicit RPC errors.
+
+namespace Composer;
+
+use Composer\Autoload\AutoloadGenerator;
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Installer\InstallationManager;
+use Composer\Package\RootPackageInterface;
+use Composer\Repository\RepositoryManager;
+use Composer\Util\Loop;
+
+class PartialComposer implements \ShirabeRustStub
+{
+    /** @var int */
+    protected $__rhandle;
+    /** @var int */
+    protected $__epoch;
+
+    public function __construct(int $rhandle, int $epoch)
+    {
+        $this->__rhandle = $rhandle;
+        $this->__epoch = $epoch;
+    }
+
+    public function __destruct()
+    {
+        \ShirabeRustObjectRegistry::release($this->__rhandle);
+    }
+
+    public function __shirabeRustHandleDescriptor(): array
+    {
+        return [
+            '__rhandle' => $this->__rhandle,
+            '__class' => static::class,
+            '__epoch' => $this->__epoch,
+        ];
+    }
+
+    public function setPackage(RootPackageInterface $package): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPackage', [$package]);
+    }
+
+    public function getPackage(): RootPackageInterface
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getPackage', []);
+    }
+
+    public function setConfig(Config $config): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setConfig', [$config]);
+    }
+
+    public function getConfig(): Config
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getConfig', []);
+    }
+
+    public function setLoop(Loop $loop): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setLoop', [$loop]);
+    }
+
+    public function getLoop(): Loop
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getLoop', []);
+    }
+
+    public function setRepositoryManager(RepositoryManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setRepositoryManager', [$manager]);
+    }
+
+    public function getRepositoryManager(): RepositoryManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getRepositoryManager', []);
+    }
+
+    public function setInstallationManager(InstallationManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setInstallationManager', [$manager]);
+    }
+
+    public function getInstallationManager(): InstallationManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getInstallationManager', []);
+    }
+
+    public function setEventDispatcher(EventDispatcher $eventDispatcher): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setEventDispatcher', [$eventDispatcher]);
+    }
+
+    public function getEventDispatcher(): EventDispatcher
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getEventDispatcher', []);
+    }
+
+    public function isGlobal(): bool
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isGlobal', []);
+    }
+
+    public function setGlobal(): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setGlobal', []);
+    }
+}