Phase 2 sub-commit 2: ModelPublisher + #[BridgeResource] + Doctrine listener

Bundle gains the model layer that bridges Doctrine entities to Mercure
without per-resource glue. Three new pieces:

- `#[BridgeResource(name: ?string)]` attribute marks an entity as a
  reactive bridge model. Topic name defaults to the lowercased class
  basename and can be overridden per resource.

- `ModelPublisher` translates entity changes into PLAN.md §4 envelopes
  ({op, id, data, version, ?correlationKey}) and dual-publishes them
  on `app://model/{name}` (collection topic) and `app://model/{name}/{id}`
  (entity topic). Entity normalisation goes through Symfony's Serializer
  (ObjectNormalizer + DateTime + BackedEnum) for predictable JSON. The
  envelope `version` field is a per-process monotonic counter — fine for
  single-instance dev mode; production should back this with a Postgres
  SEQUENCE or equivalent (noted for Phase 4).

- `DoctrineBridgeListener` registers `postPersist`/`postUpdate`/
  `postRemove` via `#[AsDoctrineListener]` and routes events through
  ModelPublisher. Entities without `#[BridgeResource]` are silently
  skipped.

Plus the correlation-key plumbing the §5 Update Semantics layer needs:

- `CorrelationContext` is a per-request holder for the originating
  request's `Idempotency-Key`.
- `CorrelationKeyListener` reads the header on `KernelEvents::REQUEST`
  and clears the context on `KernelEvents::TERMINATE` (worker mode
  hygiene). CLI mutations see no key, which is correct.

Bundle composer.json picks up `doctrine/dbal`, `doctrine/orm`,
`doctrine/doctrine-bundle`, `symfony/serializer`, `symfony/property-*`,
`symfony/uid`. PHPStan extension `phpstan-doctrine` added so the listener's
event-args types resolve. Skeleton's framework.yaml enables `serializer`
and `property_info`.

Tests: 5 new for ModelPublisher (dual publish, correlation echo, delete
op omits data, untagged entities ignored, version increments). Total:
16 tests, 45 assertions, PHPStan clean, cs-fixer clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

framework/php/src/ModelPublisher.php

@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpQml\Bridge;
+
+use PhpQml\Bridge\Attribute\BridgeResource;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Translates Doctrine entity lifecycle events into Mercure envelopes.
+ *
+ * For each change, dual-publishes to:
+ *   - `app://model/{name}`         — collection topic, watched by ReactiveListModel
+ *   - `app://model/{name}/{id}`    — entity topic, watched by ReactiveObject
+ *
+ * Topic / envelope shape per PLAN.md §4. The `correlationKey` echoes
+ * the originating request's `Idempotency-Key` (§5 *Optimistic updates*).
+ *
+ * Phase 2 uses a per-process counter for the envelope `version` field
+ * — sufficient for single-instance dev mode. Phase 4 / production should
+ * back this with a persistent monotonic source (e.g. Postgres SEQUENCE).
+ */
+final class ModelPublisher
+{
+    /** @var array<string, int> */
+    private array $versions = [];
+
+    public function __construct(
+        private readonly Publisher $publisher,
+        private readonly CorrelationContext $correlationContext,
+        private readonly NormalizerInterface $normalizer,
+    ) {
+    }
+
+    public function publishEntityChange(object $entity, string $op): void
+    {
+        $resource = $this->resolveResource($entity);
+        if (null === $resource) {
+            return;  // not a #[BridgeResource]
+        }
+
+        $name = $resource->name ?? self::deriveName($entity::class);
+        $id   = (string) $this->extractId($entity);
+
+        $envelope = [
+            'op'      => $op,
+            'id'      => $id,
+            'version' => $this->nextVersion($name),
+            'data'    => 'delete' === $op ? null : $this->normalize($entity),
+        ];
+
+        if (null !== $key = $this->correlationContext->get()) {
+            $envelope['correlationKey'] = $key;
+        }
+
+        $this->publisher->publish("app://model/{$name}", $envelope);
+        $this->publisher->publish("app://model/{$name}/{$id}", $envelope);
+    }
+
+    private function resolveResource(object $entity): ?BridgeResource
+    {
+        $reflection = new \ReflectionClass($entity);
+        $attrs      = $reflection->getAttributes(BridgeResource::class);
+        if ([] === $attrs) {
+            return null;
+        }
+
+        return $attrs[0]->newInstance();
+    }
+
+    private function extractId(object $entity): mixed
+    {
+        if (method_exists($entity, 'getId')) {
+            return $entity->getId();
+        }
+
+        $r = new \ReflectionClass($entity);
+        if ($r->hasProperty('id')) {
+            $prop = $r->getProperty('id');
+            $prop->setAccessible(true);
+
+            return $prop->getValue($entity);
+        }
+
+        throw new \LogicException(\sprintf('Cannot extract id from %s: no getId() method or $id property.', $entity::class));
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function normalize(object $entity): array
+    {
+        /** @var array<string, mixed> $data */
+        $data = $this->normalizer->normalize($entity, 'json', [
+            'circular_reference_handler' => static fn (object $o): string => (string) ($o->getId() ?? ''),
+        ]);
+
+        return $data;
+    }
+
+    private function nextVersion(string $name): int
+    {
+        if (!isset($this->versions[$name])) {
+            $this->versions[$name] = (int) (microtime(true) * 1_000_000);
+        }
+
+        return ++$this->versions[$name];
+    }
+
+    private static function deriveName(string $fqcn): string
+    {
+        $basename = substr($fqcn, (int) strrpos($fqcn, '\\') + 1);
+
+        return strtolower($basename);
+    }
+}