fix(extract): Zebrastreifen und Haltelinie auf die Kantenlaenge begrenzen

reach kommt vom breitesten Arm der ganzen Kreuzung, wurde aber fuer jeden Arm
gleich verwendet. An einer Kreuzung, wo ein kurzer Arm auf einen breiten trifft,
reicht der kurze Arm dann nicht mehr bis reach (Zebrastreifen) oder bis
reach + STOP_SETBACK + STOP_DEPTH (Haltelinie) - die Markierung entstand trotzdem
und ragte ueber das Kantenende hinaus. junction_arms() in section.py schuetzt sich
dagegen laengst; junction_marks() jetzt auch, mit getrennter Pruefung je Markierung,
weil beide unterschiedlich viel Platz brauchen.

Am echten Netz: 38 von 1.508 Armstummeln sind zu kurz fuer die Haltelinie, groesster
Ueberstand 10,6 m (Fixrunde 1 des Koordinators). Auf tatsaechliche Zufahrten
umgerechnet (Schleifen zaehlen doppelt) sind es 44 von 1.536 - die Differenz zur
Kantenzahl war anfangs unklar, ist jetzt aber nachgerechnet und im Kommentar
festgehalten. markings(graph) sinkt dadurch von 22.586 auf 22.336 Flaechen (-206
Zebrabalken, -44 Haltelinien) - genau das vorher falsch platzierte Material.

Dazu zwei bisher uebersehene Stellen mit demselben zu lockeren Testfilter
(abs(centroid.y) < 20) auf die halbe Fahrbahnbreite verengt, wie schon an den zwei
Schwesterstellen der vorigen Fixrunde - die Haltelinie des Suedarms erfuellte die
lockere Bedingung ebenfalls, next() traf bisher nur zufaellig zuerst auf den Ostarm.

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

tools/extract/leonida/marking.py

@@ -119,20 +119,34 @@ def junction_marks(graph: Graph, node: int) -> list[tuple[Polygon, str]]:
             along = _unit(origin, points[1] if len(points) > 1 else points[0])
             across = (-along[1], along[0])
             halb = SECTION[edge.klass].carriageway / 2
-            # Balken längs der Fahrtrichtung, quer über die Fahrbahn verteilt.
-            offset = -halb + BAR / 2
-            while offset <= halb - BAR / 2 + 1e-9:
-                mitte = (origin[0] + across[0] * offset, origin[1] + across[1] * offset)
-                out.append((_rect(mitte, along, across, reach, CROSSWALK_DEPTH, BAR), "zebra"))
-                offset += 2 * BAR
-            # Haltelinie quer, nur über die rechte Hälfte aus Sicht der Zufahrt. "across" ist schon
-            # als links von "along" definiert (dieselbe Konvention wie offset_curve() in _offset():
-            # positiv = links). Die Zufahrt fährt zum Knoten hin, also gegen "along" - und die Umkehr
-            # der Fahrtrichtung vertauscht links und rechts. Rechts der Einfahrt ist deshalb +across,
-            # ohne weiteres Vorzeichen: eine Probe mit offset_curve() auf der Einfahrtlinie bestätigt
-            # das (Fixrunde zu Task 9 - der Auftrag hatte hier -across und lag damit auf der Gegenspur).
-            mitte = (origin[0] + across[0] * halb / 2, origin[1] + across[1] * halb / 2)
-            out.append((_rect(mitte, along, across, reach + STOP_SETBACK, STOP_DEPTH, halb), "haltelinie"))
+            # reach kommt vom breitesten Arm der ganzen Kreuzung, gilt hier aber für diesen einen
+            # Arm - ein kurzer Arm an einer sonst breiten Kreuzung reicht oft nicht bis dorthin. Am
+            # echten Netz sind 38 von 1.508 geprüften Armstummeln zu kurz für die Haltelinie,
+            # im schlimmsten Fall um 10,6 m (Fixrunde 1 des Koordinators zu Task 9; auf die
+            # tatsächlichen Zufahrten umgerechnet, inklusive der doppelt zählenden Schleifen aus der
+            # vorigen Fixrunde, sind es 44 von 1.536). Ohne diese Prüfung ragte die Markierung über
+            # das Ende der Kante hinaus und läge neben der Straße statt darauf. Zebrastreifen und
+            # Haltelinie brauchen unterschiedlich viel Platz, deshalb getrennt geprüft statt
+            # gemeinsam verworfen.
+            länge = LineString(points).length
+            if länge >= reach + CROSSWALK_DEPTH:
+                # Balken längs der Fahrtrichtung, quer über die Fahrbahn verteilt.
+                offset = -halb + BAR / 2
+                while offset <= halb - BAR / 2 + 1e-9:
+                    mitte = (origin[0] + across[0] * offset, origin[1] + across[1] * offset)
+                    out.append((_rect(mitte, along, across, reach, CROSSWALK_DEPTH, BAR), "zebra"))
+                    offset += 2 * BAR
+            if länge >= reach + STOP_SETBACK + STOP_DEPTH:
+                # Haltelinie quer, nur über die rechte Hälfte aus Sicht der Zufahrt. "across" ist
+                # schon als links von "along" definiert (dieselbe Konvention wie offset_curve() in
+                # _offset(): positiv = links). Die Zufahrt fährt zum Knoten hin, also gegen "along" -
+                # und die Umkehr der Fahrtrichtung vertauscht links und rechts. Rechts der Einfahrt
+                # ist deshalb +across, ohne weiteres Vorzeichen: eine Probe mit offset_curve() auf
+                # der Einfahrtlinie bestätigt das (Fixrunde zu Task 9 - der Auftrag hatte hier
+                # -across und lag damit auf der Gegenspur).
+                mitte = (origin[0] + across[0] * halb / 2, origin[1] + across[1] * halb / 2)
+                out.append((_rect(mitte, along, across, reach + STOP_SETBACK, STOP_DEPTH, halb),
+                            "haltelinie"))
     return out