feat: MFA (TOTP) und Self-Service-Profilseite

Benutzer koennen jetzt selbst Zwei-Faktor-Authentifizierung einrichten
und ihr Profil verwalten (Name, E-Mail, Passwort, Profilbild).

Backend:
- Neues MfaModule (src/auth/mfa/): AES-256-GCM-verschluesselte
  TOTP-Secrets (otplib), QR-Code-Erzeugung, kurzlebige Setup-/
  Challenge-JWTs fuer den 2-Schritt-Login-Flow
- Neues ProfileModule (src/profile/): PATCH /profile,
  POST /profile/password, POST/DELETE/GET /profile/avatar,
  POST /profile/mfa/enroll(/confirm), POST /profile/mfa/disable -
  alle self-scoped ueber actor.id, ohne @RequirePermission (siehe
  ALLOWLIST in authorization-coverage.e2e-spec.ts)
- AuthService.login() zweistufig: bei aktivem MFA erst
  { mfaRequired, mfaToken } statt Tokens, neuer Endpunkt
  POST /auth/mfa/verify schliesst den Flow ab
- Admin-Recovery: POST /users/:id/mfa/reset (users:update) fuer
  verlorene MFA-Geraete, da es keinen E-Mail-Reset-Flow gibt

Frontend:
- Login-Seite mit zweitem Schritt fuer den TOTP-Code
- Neue Profilseite (/profile, ausserhalb des admin-only
  Settings-Bereichs): Profilbild, Name/E-Mail, Passwort, MFA-Ein-/
  Ausrichtung mit QR-Code-Dialog
- Header zeigt jetzt Avatar mit Dropdown (Profil/Abmelden) statt
  nur E-Mail-Text
- Admin-Users-Tabelle zeigt MFA-Status + Reset-Button

Haertung nach Security-Review (Backend/Frontend-Diff, kein CRITICAL,
mehrere MEDIUM behoben):
- Access-Token wird bei Passwortwechsel sofort ungueltig
  (User.passwordChangedAt + JWT-iat-Vergleich in
  PermissionResolverService.isTokenValid, vorher isUserActive) statt
  erst nach bis zu 15 Minuten
- E-Mail-Aenderung verlangt jetzt aktuelles Passwort
- POST /profile/password und /profile/mfa/disable haben jetzt das
  gleiche strikte Throttling wie Login (SENSITIVE_ACTION_THROTTLE)
- Kein stiller leerer Verschluesselungs-Key-Fallback mehr (wirft
  jetzt explizit)

Bewusst zurueckgestellt (dokumentiert, kein aktiver Exploit-Pfad):
dedizierter Verschluesselungs-Key fuer MFA-Secrets statt
JWT_ACCESS_SECRET-Ableitung, dedizierte users:mfa-reset-Permission
statt users:update, separate JWT-Secrets pro Token-Zweck.

Verifiziert: tsc/eslint clean, 297/297 Backend- + 31/31
Frontend-Unit-Tests, Build clean auf beiden Projekten. e2e weiterhin
durch bekanntes WSL2/Postgres-Problem blockiert. Unabhaengiges
Security- und Code-Quality-Review durchgefuehrt (0 CRITICAL, 0 HIGH).

ApiCore-Backend/src/auth/mfa/mfa.service.ts

@@ -0,0 +1,108 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import * as QRCode from 'qrcode';
+import { decryptMfaSecret, encryptMfaSecret } from './mfa-crypto.util';
+import { buildTotpUri, generateTotpSecret, verifyTotpCode } from './totp.util';
+
+const SETUP_TOKEN_TTL = '10m';
+const CHALLENGE_TOKEN_TTL = '5m';
+const SETUP_TOKEN_PURPOSE = 'mfa-setup';
+const CHALLENGE_TOKEN_PURPOSE = 'mfa-challenge';
+
+interface SetupTokenPayload {
+  sub: string;
+  secret: string;
+  purpose: typeof SETUP_TOKEN_PURPOSE;
+}
+
+interface ChallengeTokenPayload {
+  sub: string;
+  purpose: typeof CHALLENGE_TOKEN_PURPOSE;
+}
+
+export interface MfaEnrollment {
+  secret: string;
+  qrCodeSvg: string;
+  otpauthUri: string;
+  setupToken: string;
+}
+
+@Injectable()
+export class MfaService {
+  constructor(private readonly jwtService: JwtService) {}
+
+  async startEnrollment(userId: string, email: string): Promise<MfaEnrollment> {
+    const secret = generateTotpSecret();
+    const otpauthUri = buildTotpUri(secret, email);
+    const qrCodeSvg = await QRCode.toString(otpauthUri, {
+      type: 'svg',
+      margin: 1,
+      width: 256,
+    });
+    const setupToken = this.jwtService.sign(
+      { sub: userId, secret, purpose: SETUP_TOKEN_PURPOSE },
+      { secret: process.env.JWT_ACCESS_SECRET, expiresIn: SETUP_TOKEN_TTL },
+    );
+    return { secret, qrCodeSvg, otpauthUri, setupToken };
+  }
+
+  /** Returns the plaintext secret from a setup token once the enrollment code checks out. */
+  async confirmEnrollment(
+    userId: string,
+    setupToken: string,
+    email: string,
+    code: string,
+  ): Promise<{ encryptedSecret: string }> {
+    let payload: SetupTokenPayload;
+    try {
+      payload = this.jwtService.verify<SetupTokenPayload>(setupToken, {
+        secret: process.env.JWT_ACCESS_SECRET,
+      });
+    } catch {
+      throw new UnauthorizedException(
+        'Setup-Token ungültig oder abgelaufen, MFA-Einrichtung neu starten',
+      );
+    }
+    if (payload.purpose !== SETUP_TOKEN_PURPOSE || payload.sub !== userId) {
+      throw new UnauthorizedException('Setup-Token ungültig');
+    }
+    const isValid = await verifyTotpCode(payload.secret, email, code);
+    if (!isValid) {
+      throw new UnauthorizedException('Code ungültig');
+    }
+    return { encryptedSecret: encryptMfaSecret(payload.secret) };
+  }
+
+  signChallengeToken(userId: string): string {
+    return this.jwtService.sign(
+      { sub: userId, purpose: CHALLENGE_TOKEN_PURPOSE },
+      { secret: process.env.JWT_ACCESS_SECRET, expiresIn: CHALLENGE_TOKEN_TTL },
+    );
+  }
+
+  verifyChallengeToken(challengeToken: string): { userId: string } {
+    let payload: ChallengeTokenPayload;
+    try {
+      payload = this.jwtService.verify<ChallengeTokenPayload>(challengeToken, {
+        secret: process.env.JWT_ACCESS_SECRET,
+      });
+    } catch {
+      throw new UnauthorizedException(
+        'Anmeldung abgelaufen, bitte erneut mit E-Mail und Passwort anmelden',
+      );
+    }
+    if (payload.purpose !== CHALLENGE_TOKEN_PURPOSE) {
+      throw new UnauthorizedException('Ungültiger Token');
+    }
+    return { userId: payload.sub };
+  }
+
+  async verifyCode(
+    encryptedSecret: string,
+    email: string,
+    code: string,
+  ): Promise<boolean> {
+    const secret = decryptMfaSecret(encryptedSecret);
+    return verifyTotpCode(secret, email, code);
+  }
+}