Verwaltbare Einheiten mit Umrechnung + Chargen bearbeiten + gezieltes Auslagern

Einheiten (neu):
- Tabelle units (name, kind=count|weight|volume, factor, is_builtin); eingebaut
  Stueck/Gramm/Kilogramm/Milliliter/Liter, Admin kann eigene anlegen (z.B. Pfund=500g).
- Bestaende bleiben intern in kanonischer Basis (Stueck/Gramm/Milliliter);
  Product.display_unit_id und Group.min_stock_unit_id als nullable FKs.
- Neuer Umrechnungs-Service (services/conversion.py) ersetzt die feste Einheitenlogik;
  Ein-/Auslagern und Gruppen-Mindestbestand rechnen ueber den Faktor.
- Gruppen-Mindestbestand mit Einheit; Gruppenbestand summiert nur Produkte
  passender Art. Neue Verwaltungsseite "Einheiten" (Admin).
- Schonende Migration beim Start: ADD COLUMN IF NOT EXISTS (Postgres), damit
  bestehende Installationen ihre Daten behalten.

Chargen:
- PATCH /lots/{id} und DELETE /lots/{id}: Menge/MHD korrigieren, Charge loeschen
  (wird als Korrektur-Bewegung protokolliert). Bearbeitung im Produktdetail.

Auslagern:
- Optionales lot_id: gezielt aus einer bestimmten Charge/MHD abbuchen statt FEFO;
  Auswahl-Dropdown in der Auslagern-Seite.

Sonstiges: Roadmap aktualisiert, Tests fuer die Umrechnung.

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

backend/app/services/conversion.py

@@ -0,0 +1,90 @@
+"""Einheiten-Umrechnung auf Basis der verwaltbaren Unit-Tabelle.
+
+Bestände werden immer in der kanonischen Basiseinheit der jeweiligen Art
+gespeichert: Stück (count), Gramm (weight), Milliliter (volume). Verwaltete
+Einheiten (z.B. Kilogramm, Liter, Pfund) rechnen über ihren Faktor dorthin um.
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from ..models import BaseUnit, Product, Unit, UnitKind
+
+BASE_OF_KIND: dict[UnitKind, BaseUnit] = {
+    UnitKind.count: BaseUnit.piece,
+    UnitKind.weight: BaseUnit.gram,
+    UnitKind.volume: BaseUnit.milliliter,
+}
+KIND_OF_BASE: dict[BaseUnit, UnitKind] = {v: k for k, v in BASE_OF_KIND.items()}
+
+BASE_LABEL: dict[BaseUnit, str] = {
+    BaseUnit.piece: "Stück",
+    BaseUnit.gram: "Gramm",
+    BaseUnit.milliliter: "Milliliter",
+}
+
+PACKAGE_TOKENS = {"package", "packung", "pkg", "pack"}
+
+# Kürzel/Aliase, die direkt auf eingebaute Einheitennamen zeigen.
+_ALIAS = {
+    "g": "gramm", "gram": "gramm", "gramm": "gramm",
+    "kg": "kilogramm", "kilogramm": "kilogramm",
+    "ml": "milliliter", "milliliter": "milliliter",
+    "l": "liter", "liter": "liter",
+    "stück": "stück", "stueck": "stück", "st": "stück", "stk": "stück", "piece": "stück",
+}
+
+
+class ConversionError(ValueError):
+    """Fachlicher Fehler bei der Einheiten-Umrechnung."""
+
+
+def kind_of_product(product: Product) -> UnitKind:
+    return KIND_OF_BASE[product.base_unit]
+
+
+def find_unit(db: Session, token: str) -> Unit | None:
+    t = token.strip().lower()
+    t = _ALIAS.get(t, t)
+    return db.query(Unit).filter(func.lower(Unit.name) == t).first()
+
+
+def to_base(db: Session, product: Product, quantity: float, unit_token: str) -> float:
+    """Rechnet eine Menge (in unit_token) in die Basiseinheit des Produkts um."""
+    if quantity <= 0:
+        raise ConversionError("Menge muss größer als 0 sein")
+
+    t = (unit_token or "").strip().lower()
+    if t in PACKAGE_TOKENS:
+        if not product.package_size or product.package_size <= 0:
+            raise ConversionError(
+                "Für dieses Produkt ist keine Packungsgröße hinterlegt."
+            )
+        return quantity * product.package_size
+
+    unit = find_unit(db, t)
+    if unit is None:
+        raise ConversionError(f"Unbekannte Einheit: {unit_token}")
+    if unit.kind != kind_of_product(product):
+        raise ConversionError(
+            f"Einheit '{unit.name}' passt nicht zur Art des Produkts "
+            f"({BASE_LABEL[product.base_unit]})."
+        )
+    return quantity * unit.factor
+
+
+def resolve_product_unit(db: Session, unit_id: int) -> tuple[BaseUnit, int]:
+    """Ermittelt zu einer gewählten Einheit die kanonische Basiseinheit + Anzeige-ID."""
+    unit = db.get(Unit, unit_id)
+    if unit is None:
+        raise ConversionError("Einheit nicht gefunden")
+    return BASE_OF_KIND[unit.kind], unit.id
+
+
+def display_unit_info(product: Product) -> tuple[str, float]:
+    """Name und Faktor der Anzeigeeinheit des Produkts (Fallback: Basiseinheit)."""
+    if product.display_unit is not None:
+        return product.display_unit.name, product.display_unit.factor
+    return BASE_LABEL[product.base_unit], 1.0