fix(rbac) : rattache le rôle de base « user » et gate le frontend par permission

Un user avec des permissions sur le rôle RBAC « user » ne voyait rien : le
ROLE_USER legacy n'a aucun lien avec le RBAC et getEffectivePermissions() ne lit
que rbacRoles + permissions directes, alors qu'aucun user n'était rattaché au
rôle « user » (table user_role vide, jamais backfillée).

Backend
- DefaultUserRoleAssigner + UserDefaultRoleListener (prePersist) : tout nouvel
  utilisateur est rattaché au rôle « user » sur tous les chemins de persistance.
- Commande app:assign-default-roles (backfill idempotent) + ajout au deploy.sh.
- AppFixtures : seed des rôles système avant la création des users.

Frontend (gating par permission au lieu de ROLE_ADMIN legacy)
- Nouveau middleware « permission » + augmentation PageMeta : definePageMeta
  ({ permission }) (string = requise, array = any), ROLE_ADMIN bypasse.
- Pages directory/reporting/admin gatées par permission ; SidebarFilter accepte
  une liste de permissions (any) ; section admin sans gate de rôle.
- team-absences reste en ROLE_ADMIN (module Absence non RBAC-isé côté backend).

src/Module/Core/Application/Rbac/DefaultUserRoleAssigner.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Application\Rbac;
+
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Core\Domain\Repository\RoleRepositoryInterface;
+use App\Module\Core\Domain\Security\SystemRoles;
+use Doctrine\ORM\EntityManagerInterface;
+
+use function count;
+
+/**
+ * Garantit que chaque utilisateur porte le rôle RBAC de base « user ».
+ *
+ * Le rôle « user » est le socle commun : il porte les permissions par défaut
+ * des non-admins. Sans rattachement explicite dans user_role,
+ * User::getEffectivePermissions() reste vide — le ROLE_USER legacy n'a aucun
+ * lien avec le rôle RBAC « user ».
+ */
+final readonly class DefaultUserRoleAssigner
+{
+    public function __construct(
+        private RoleRepositoryInterface $roles,
+        private EntityManagerInterface $em,
+    ) {}
+
+    /**
+     * Ajoute le rôle « user » à l'utilisateur s'il ne l'a pas déjà.
+     * Ne flush pas : appelé en prePersist (création) ou par le backfill.
+     */
+    public function ensureDefaultRole(User $user): void
+    {
+        $userRole = $this->roles->findByCode(SystemRoles::USER_CODE);
+        if (null === $userRole) {
+            // Rôle non seedé : dégradation gracieuse, on ne bloque pas la création.
+            return;
+        }
+
+        foreach ($user->getRbacRoles() as $role) {
+            if (SystemRoles::USER_CODE === $role->getCode()) {
+                return;
+            }
+        }
+
+        $user->addRbacRole($userRole);
+    }
+
+    /**
+     * Rattache le rôle « user » à tous les utilisateurs qui ne l'ont pas.
+     * Idempotent. Retourne le nombre d'utilisateurs modifiés.
+     */
+    public function backfill(): int
+    {
+        $userRole = $this->roles->findByCode(SystemRoles::USER_CODE);
+        if (null === $userRole) {
+            return 0;
+        }
+
+        /** @var list<User> $users */
+        $users = $this->em
+            ->createQuery('SELECT u FROM '.User::class.' u WHERE :role NOT MEMBER OF u.rbacRoles')
+            ->setParameter('role', $userRole)
+            ->getResult()
+        ;
+
+        foreach ($users as $user) {
+            $user->addRbacRole($userRole);
+        }
+
+        $this->em->flush();
+
+        return count($users);
+    }
+}

src/Module/Core/Infrastructure/Console/AssignDefaultRolesCommand.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Console;
+
+use App\Module\Core\Application\Rbac\DefaultUserRoleAssigner;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+use function sprintf;
+
+#[AsCommand(
+    name: 'app:assign-default-roles',
+    description: 'Rattache le rôle RBAC de base « user » à tous les utilisateurs qui ne l\'ont pas.',
+)]
+final class AssignDefaultRolesCommand extends Command
+{
+    public function __construct(private readonly DefaultUserRoleAssigner $assigner)
+    {
+        parent::__construct();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io    = new SymfonyStyle($input, $output);
+        $count = $this->assigner->backfill();
+        $io->success(sprintf('%d utilisateur(s) rattaché(s) au rôle « user ».', $count));
+
+        return Command::SUCCESS;
+    }
+}

src/Module/Core/Infrastructure/EventListener/UserDefaultRoleListener.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\EventListener;
+
+use App\Module\Core\Application\Rbac\DefaultUserRoleAssigner;
+use App\Module\Core\Domain\Entity\User;
+use Doctrine\ORM\Event\PrePersistEventArgs;
+
+/**
+ * Assigne le rôle RBAC de base « user » à tout nouvel utilisateur qui n'en a pas,
+ * quel que soit le chemin de persistance (API Platform, fixtures, MCP).
+ *
+ * Sans ça, un user créé n'est rattaché à aucun rôle RBAC et ses permissions
+ * effectives restent vides, peu importe les permissions portées par le rôle.
+ */
+final readonly class UserDefaultRoleListener
+{
+    public function __construct(private DefaultUserRoleAssigner $assigner) {}
+
+    public function prePersist(User $user, PrePersistEventArgs $args): void
+    {
+        $this->assigner->ensureDefaultRole($user);
+    }
+}