Gruppen: Obergruppen + Mindestbestaende nur noch je Lagerort (Backend)

Zwei zusammenhaengende Umbauten, weil sie dieselben Stellen betreffen.

Obergruppen: Gruppen bilden jetzt einen gerichteten azyklischen Graphen statt
einer flachen Liste. Eine Gruppe darf unter MEHREREN Obergruppen haengen -
"Grillwurst" unter "Wurst" UND unter "Grillgut"; mit einem einzelnen parent_id
waere genau das nicht abbildbar. Bestand und Mindestbestand einer Gruppe zaehlen
den gesamten Untergraphen, wobei eine ueber zwei Wege erreichbare Untergruppe
nur einmal zaehlt (services/gruppen.py arbeitet durchgaengig mit Mengen).
Product.group_id bleibt unveraendert - ein Artikel haengt weiter an genau einer
Gruppe.

Mindestbestaende: der separate Gesamt-Mindestbestand entfaellt. Er wird zur
Zeile mit location_id NULL ("Ueberall") und ist damit die Wurzel ueber allen
Lagerorten - dieselbe Verrechnung wie bei verschachtelten Orten greift jetzt
auch zwischen Ueberall und Kueche, wodurch derselbe Artikel nicht mehr doppelt
in der Einkaufsliste steht. Alle Werte liegen einheitlich in Basiseinheiten
statt in drei verschiedenen Einheiten nebeneinander; das Umrechnen beim
Umschalten der Erfassungseinheit entfaellt dadurch ersatzlos.

_netted_topups nimmt die Hierarchie jetzt als Parameter und faltet damit
Lagerort-Baum und Gruppen-Graph. Verrechnet wird zwischen zwei Gruppen nur,
wenn die zaehlenden Artikel der Untergruppe eine Teilmenge der Obergruppe sind -
zaehlt die Obergruppe in Kilogramm und die Untergruppe in Stueck, kommt ein Kauf
dort oben nicht an.

Die vierfach kopierte Bestandssumme wandert in Sammelabfragen
(summe_bestand_base), sonst vervielfacht der transitive Teilgraph die Abfragen.

Einmalige Datenwanderung beim Start (Merker in den Einstellungen), 18 neue
Tests - darunter Doppelzaehlung ueber zwei Wege, Ringschutz und die bewusst
offene Grenze bei zwei Obergruppen mit gemeinsamer Untergruppe.

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

backend/app/services/stock.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from datetime import date
 
 from sqlalchemy import asc, func
@@ -215,6 +216,65 @@ def current_stock(db: Session, product_id: int) -> float:
     return float(sum(q for (q,) in total))
 
 
+def summe_bestand_base(db: Session, produkte: Sequence[Product]) -> float:
+    """Gesamtbestand mehrerer Artikel (Basiseinheiten) in EINER Abfrage.
+
+    Ersetzt ``sum(current_stock(db, p.id) for p in …)``: das setzte je Artikel
+    zwei Abfragen ab. Seit eine Gruppe die Artikel ihres ganzen Untergruppen-
+    Graphen zaehlt, sind das schnell hunderte.
+    """
+    if not produkte:
+        return 0.0
+    # Gleiche Fallunterscheidung wie current_stock: Einzelstuecke zaehlen ihre
+    # Items, alle anderen summieren die Lot-Mengen.
+    einzel = [p.id for p in produkte if p.individual]
+    lots = [p.id for p in produkte if not p.individual]
+    total = 0.0
+    if lots:
+        total += float(
+            db.query(func.coalesce(func.sum(Lot.quantity), 0.0))
+            .filter(Lot.product_id.in_(lots))
+            .scalar()
+            or 0.0
+        )
+    if einzel:
+        total += float(
+            db.query(func.count(Item.id)).filter(Item.product_id.in_(einzel)).scalar() or 0
+        )
+    return total
+
+
+def summe_bestand_im_subtree_base(
+    db: Session, produkte: Sequence[Product], location_id: str
+) -> float:
+    """Wie ``summe_bestand_base``, aber nur an einem Lagerort inkl. Unterorten.
+
+    Chargen ohne Lagerort liegen in keinem Subtree und zaehlen hier bewusst
+    nicht mit – im Gesamtbestand („Ueberall") dagegen schon.
+    """
+    if not produkte:
+        return 0.0
+    ids = {location_id} | descendant_location_ids(db, location_id)
+    einzel = [p.id for p in produkte if p.individual]
+    lots = [p.id for p in produkte if not p.individual]
+    total = 0.0
+    if lots:
+        total += float(
+            db.query(func.coalesce(func.sum(Lot.quantity), 0.0))
+            .filter(Lot.product_id.in_(lots), Lot.location_id.in_(ids))
+            .scalar()
+            or 0.0
+        )
+    if einzel:
+        total += float(
+            db.query(func.count(Item.id))
+            .filter(Item.product_id.in_(einzel), Item.location_id.in_(ids))
+            .scalar()
+            or 0
+        )
+    return total
+
+
 def location_stock_base(db: Session, product: Product, location_id: str) -> float:
     """Bestand eines Produkts an EINEM Lagerort (in Basiseinheiten).