feat : add audit log (table, writer, listener, API, admin UI, timeline)

Implemente le journal d'audit append-only sur toutes les mutations Doctrine
des entites portant #[Auditable]. Couvre les 5 tickets de doc/audit-log.md :

1. Table PG audit_log (uuid PK, jsonb changes, index entity/time/performer)
   + AuditLogWriter (DBAL connexion dediee audit, blacklist defense-in-depth
   sur password/plainPassword/token/secret) + RequestIdProvider (UUID v4 par
   requete HTTP principale).
2. Attributs Auditable / AuditIgnore dans Shared/Domain/Attribute/
   + AuditListener (onFlush capture + postFlush ecriture hors transaction ORM,
   pattern swap-and-clear, erreurs loguees jamais propagees). User annote.
3. API Platform read-only /api/audit-logs (permission core.audit_log.view)
   avec filtres entity_type / entity_id / action / performed_by / plage
   performed_at + DbalPaginator implementant PaginatorInterface (hydra:view
   genere automatiquement).
4. Page admin /admin/audit-log : tableau pagine, filtres persistes en query
   params, row expandable (diff + timeline de l'entite), entree sidebar avec
   permission. Composable useAuditLog avec resetAuditLog() auto-enregistre
   sur onAuthSessionCleared.
5. Composant AuditTimeline reutilisable : garde permission, lazy loading,
   dates relatives FR, skeleton loader.

Fix connexe : phpunit.dist.xml forcait APP_ENV=dev via <env> ce qui cablait
framework.test=false et rendait test.service_container indisponible ; le
JWT_PASSPHRASE ne matchait pas non plus les cles dev. Corrige en meme temps
pour debloquer la suite de tests.

src/Module/Core/Infrastructure/Audit/AuditLogWriter.php

@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Audit;
+
+use DateTimeImmutable;
+use DateTimeZone;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Types\Types;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Uid\Uuid;
+
+/**
+ * Service bas-niveau responsable de l'ecriture dans la table `audit_log`.
+ *
+ * Utilise une connexion DBAL dediee `audit` (meme DSN que `default`, service
+ * separe) pour ecrire hors de la transaction ORM : indispensable pour que
+ * les lignes d'audit survivent meme si le flush applicatif est rollback,
+ * et pour eviter tout entanglement transactionnel en batch (fixtures).
+ *
+ * Les cles sensibles (password, plainPassword, token, secret) sont filtrees
+ * en defense-in-depth meme si les entites declarent deja ces proprietes
+ * #[AuditIgnore].
+ *
+ * Erreur silencieuse : en cas d'echec SQL, on lance pas l'exception plus
+ * haut — l'audit ne doit jamais faire crasher un flux metier. Le listener
+ * wrappe l'appel dans un try/catch + logger (cf. AuditListener).
+ */
+final class AuditLogWriter
+{
+    /** @var list<string> cles systematiquement strippees du payload `changes` */
+    private const array SENSITIVE_KEYS = ['password', 'plainPassword', 'token', 'secret'];
+
+    public function __construct(
+        #[Autowire(service: 'doctrine.dbal.audit_connection')]
+        private readonly Connection $connection,
+        private readonly Security $security,
+        private readonly RequestStack $requestStack,
+        private readonly RequestIdProvider $requestIdProvider,
+    ) {}
+
+    /**
+     * Ecrit une ligne d'audit.
+     *
+     * @param string               $entityType Format "module.Entity" (ex: "core.User")
+     * @param string               $entityId   ID de l'entite (int ou UUID serialise)
+     * @param string               $action     create|update|delete
+     * @param array<string, mixed> $changes    Payload JSON (filtre des cles sensibles)
+     */
+    public function log(
+        string $entityType,
+        string $entityId,
+        string $action,
+        array $changes,
+    ): void {
+        $filteredChanges = $this->stripSensitive($changes);
+
+        $this->connection->insert('audit_log', [
+            'id'           => Uuid::v7()->toRfc4122(),
+            'entity_type'  => $entityType,
+            'entity_id'    => $entityId,
+            'action'       => $action,
+            'changes'      => $filteredChanges,
+            'performed_by' => $this->security->getUser()?->getUserIdentifier() ?? 'system',
+            'performed_at' => new DateTimeImmutable('now', new DateTimeZone('UTC')),
+            'ip_address'   => $this->requestStack->getCurrentRequest()?->getClientIp(),
+            'request_id'   => $this->requestIdProvider->getRequestId(),
+        ], [
+            // Types de conversion DBAL : JSON encode jsonb + datetimetz.
+            'changes'      => Types::JSON,
+            'performed_at' => Types::DATETIMETZ_IMMUTABLE,
+        ]);
+    }
+
+    /**
+     * Supprime recursivement les cles sensibles du payload.
+     *
+     * Utile pour les snapshots complets (create/delete) ou les changes
+     * d'update : le listener prefiltre deja mais on garde cette garde
+     * en defense-in-depth si un appelant direct oublie `#[AuditIgnore]`.
+     *
+     * @param array<string, mixed> $data
+     *
+     * @return array<string, mixed>
+     */
+    private function stripSensitive(array $data): array
+    {
+        foreach (self::SENSITIVE_KEYS as $sensitiveKey) {
+            unset($data[$sensitiveKey]);
+        }
+
+        return $data;
+    }
+}