feat: Phase 1 – Konten, Kategorien, Transaktionen, EZB-Währungsumrechnung

Backend:
- Modelle + Migration 0002: accounts, account_identifiers, category_groups,
  categories, transactions, exchange_rates (alle owner-gescoped).
- EZB-Kursdienst (90-Tage/Historie) + Backfill-Skript; Umrechnung EUR<->CHF zum
  Buchungsdatum mit lokalem Cache und manueller Übersteuerung; EUR-Pivot
  (amount_eur_cents) eingefroren.
- Kontostände + Netto-Vermögen (Umrechnung in Hauptwährung).
- Router: accounts (inkl. IBAN-Identifikatoren), categories (Gruppen+Kategorien),
  transactions (Ausgabe/Einnahme/Transfer, cross-currency), rates.
- Gruppierte Standard-Kategorien je Nutzer beim Anlegen.
- pytest-Suite: Währung, Salden, Cross-Currency-Transfer, Nutzer-Isolation.

Frontend:
- Seiten Konten, Kategorien, Buchungen; Icon-Chip, Geldbetrag mit Umrechnung,
  Icon-/Farbwähler, Modal; erweitertes SVG-Icon-Set (Konto-/Kategorie-Icons).
- Währungs-/Datumsformatierung (EUR de-DE, CHF de-CH), i18n DE/EN erweitert.
- Live-Umrechnungs-Vorschau im Transfer-Formular.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/app/services/currency.py

@@ -0,0 +1,82 @@
+"""Währungsumrechnung EUR<->CHF über die lokal gecachten EZB-Referenzkurse.
+
+Kurse werden als ``rate_per_eur`` gespeichert: wie viele Einheiten der Währung
+ein Euro wert war (EUR ist implizit 1.0). Umgerechnet wird immer mit dem Kurs zum
+Buchungsdatum; fehlt ein Kurs für genau diesen Tag (Wochenende/Feiertag), wird der
+letzte verfügbare Börsentag davor genommen.
+"""
+
+from datetime import date
+from decimal import Decimal, ROUND_HALF_UP
+
+from sqlalchemy.orm import Session
+
+from ..models import ExchangeRate
+
+
+def rate_on(db: Session, currency: str, on: date) -> Decimal | None:
+    """Kurs (Währungseinheiten je 1 EUR) am Tag ``on`` oder dem letzten davor."""
+    if currency == "EUR":
+        return Decimal(1)
+    row = (
+        db.query(ExchangeRate)
+        .filter(ExchangeRate.currency == currency, ExchangeRate.date <= on)
+        .order_by(ExchangeRate.date.desc())
+        .first()
+    )
+    return Decimal(str(row.rate_per_eur)) if row is not None else None
+
+
+def _round_cents(value: Decimal) -> int:
+    return int(value.quantize(Decimal(1), rounding=ROUND_HALF_UP))
+
+
+def to_eur_cents(
+    db: Session, amount_cents: int, currency: str, on: date, fx_rate: float | None = None
+) -> int | None:
+    """Rechnet einen Betrag in Kontowährung in EUR-Cent um.
+
+    ``fx_rate`` (Kontowährung je 1 EUR) hat Vorrang vor dem EZB-Kurs. Gibt None
+    zurück, wenn kein Kurs verfügbar ist (Aufrufer entscheidet über Fallback)."""
+    if currency == "EUR":
+        return amount_cents
+    rate = Decimal(str(fx_rate)) if fx_rate else rate_on(db, currency, on)
+    if not rate or rate == 0:
+        return None
+    return _round_cents(Decimal(amount_cents) / rate)
+
+
+def from_eur_cents(db: Session, eur_cents: int, currency: str, on: date) -> int | None:
+    """Rechnet EUR-Cent in die Zielwährung um (Kurs zum Tag ``on``)."""
+    if currency == "EUR":
+        return eur_cents
+    rate = rate_on(db, currency, on)
+    if rate is None:
+        return None
+    return _round_cents(Decimal(eur_cents) * rate)
+
+
+def convert(
+    db: Session,
+    amount_cents: int,
+    from_ccy: str,
+    to_ccy: str,
+    on: date,
+    fx_rate: float | None = None,
+) -> int | None:
+    """Rechnet zwischen zwei Währungen um (über EUR als Pivot)."""
+    if from_ccy == to_ccy:
+        return amount_cents
+    eur = to_eur_cents(db, amount_cents, from_ccy, on, fx_rate)
+    if eur is None:
+        return None
+    return from_eur_cents(db, eur, to_ccy, on)
+
+
+def compute_amount_eur_cents(
+    db: Session, amount_cents: int, currency: str, on: date, fx_rate: float | None = None
+) -> int:
+    """Eingefrorener EUR-Wert für eine Transaktion. Fällt notfalls (kein Kurs
+    verfügbar) auf 1:1 zurück, damit das Speichern nie scheitert."""
+    eur = to_eur_cents(db, amount_cents, currency, on, fx_rate)
+    return eur if eur is not None else amount_cents