fix(modules): a self-registered class is no longer wired twice by a later scan

CodeRabbit found a real bug in the registerClass() I added, and it was mine.

register() did `$this->mappings = $this->scanner->scan($paths)` — assignment, not
merge. So a package that called registerClass() from its own provider had that
record thrown away the moment the framework's scan ran, which meant the
idempotency guard inside registerClass() had nothing left to see. If the scan
also found the class, it wired a second listener and the handler ran twice on
every event.

The order is not hypothetical. A package provider's register() runs whenever
Laravel gets to it, which may be before LifecycleEventProvider's — so the
sequence that breaks is the ordinary one, not a corner.

Proven before fixing, with the fixture registering both ways:

    assertCount(1, $displaced)
    Failed asserting that actual size 2 matches expected size 1

register() now merges into what is already there and skips a class already
registered for that event — the same guard addPaths() has always had, which is
where I should have looked before writing a second registration path.

  ./vendor/bin/pest --testsuite=Feature,Unit   267 -> 268 passed, 0 failed
  ./vendor/bin/pest --testsuite=Module         448 failed / 308 passed, unchanged
  vendor/bin/pint --test                       pass
  vendor/bin/phpstan analyse                   no errors

Co-Authored-By: Virgil <virgil@lethean.io>

Author: Snider

src/Core/ModuleRegistry.php

@@ -106,12 +106,18 @@ public function register(array $paths): void
             return;
         }
 
-        $this->mappings = $this->scanner->scan($paths);
-
-        foreach ($this->mappings as $event => $listeners) {
-            $sorted = $this->sortByPriority($listeners);
+        // Merged into what is already here, not assigned over it. A package that
+        // calls registerClass() from its own provider may well do so before this
+        // runs — provider order is Laravel's to decide — and assigning threw that
+        // record away, so the guard below could not see it. The class was then
+        // wired a second time and its handler ran twice on every event.
+        foreach ($this->scanner->scan($paths) as $event => $listeners) {
+            foreach ($this->sortByPriority($listeners) as $moduleClass => $config) {
+                if (isset($this->mappings[$event][$moduleClass])) {
+                    continue;
+                }
 
-            foreach ($sorted as $moduleClass => $config) {
+                $this->mappings[$event][$moduleClass] = $config;
                 Event::listen($event, new LazyModuleListener($moduleClass, $config['method']));
             }
         }

tests/Feature/ModuleRegistryTest.php

@@ -206,4 +206,32 @@ public function test_register_class_ignores_a_class_without_listens(): void
 
         $this->assertSame([], $registry->getModules());
     }
+
+    /**
+     * A self-registered class must not be registered a second time by a later scan.
+     *
+     * register() replaced $mappings wholesale, which threw away the record that
+     * registerClass() had already wired a class — so the idempotency guard could
+     * not see it, and a class that both self-registers and is scanned got two
+     * listeners and ran its handler twice. The order is not hypothetical: a
+     * package provider's register() runs whenever Laravel gets to it, which may
+     * be before the framework's own scan.
+     */
+    public function test_register_does_not_duplicate_a_self_registered_class(): void
+    {
+        $registry = new ModuleRegistry(new ModuleScanner());
+
+        $registry->registerClass(\Core\Tests\Fixtures\Mod\Displaced\Boot::class);
+        $registry->register([__DIR__.'/../Fixtures/Mod']);
+
+        $event = new WebRoutesRegistering();
+        Event::dispatch($event);
+
+        $displaced = array_filter(
+            $event->viewRequests(),
+            fn (array $request): bool => $request[0] === 'displaced',
+        );
+
+        $this->assertCount(1, $displaced, 'the handler ran more than once');
+    }
 }