fix(extract): Kreuzungsmarkierung am tatsächlichen Punkt verankern, nicht am Knoten

Nacharbeit zu Befund 3, beim Nachmessen am echten Netz entdeckt: Die erste
Korrektur (Richtung aus origin -> interpolate(reach) statt aus points[1])
reichte an zwei Stellen nicht.

Erstens kann eine Schleife geradewegs von ihrem Knoten weg- und auf
demselben Weg wieder zurücklaufen - am echten Netz eine 21,63 m lange
Boulevard-Schleife, deren Punktliste den Hinweg exakt rückwärts
wiederholt. Landet reach nahe dieser Kehre, zeigt die Sehne vom Ursprung
weiter nach außen, obwohl die Kante dort längst umkehrt: Die Markierung
lag an dieser einen Schleife weiterhin vollständig (100 %) neben der
Fahrbahn. Die Richtung kommt jetzt aus dem letzten Teilstück von
substring(line, 0, reach) - der tatsächlichen Anfahrtsrichtung an der
Schnittstelle, gleich wohin die Kante von dort aus weiterläuft.

Zweitens blieb "origin" (der Kreuzungsknoten) der Anker für Balken und
Haltelinie. origin und der Punkt bei Streckenlänge reach fallen nur auf
einer geraden Kante zusammen - mit der neuen Anfahrtsrichtung, aber dem
Knoten als Anker, läge selbst eine gerade Fortsetzung ab reach
systematisch daneben, sobald die Kante zwischen Knoten und reach von der
reinen Ursprungsrichtung abweicht. Anker ist jetzt der tatsächliche Punkt
auf der Kante bei Streckenlänge min(reach, länge).

Nachgemessen am echten Netz: von 452,65 m² (vor Befund 3) über 342,66 m²
(nur die erste Korrektur) auf 110,06 m² (0,25 % der Gesamtfläche) - beide
Korrekturen zusammen eine Verbesserung um 75,7 %. Der Rest ist eine engere
Spielart desselben Problems: Ein Bogen kann auch noch zwischen reach und
reach + STOP_SETBACK + STOP_DEPTH abknicken, was ein einzelner
Richtungsstrahl nicht mehr auffangen kann - das verlangte die vom Befund
selbst genannte, größere Alternative ("die Markierung entlang der
tatsächlichen Kante aufbauen"), die diese Fixwelle nicht umsetzt. Siehe
Fixwelle-Bericht für die Einzelheiten und die verbleibenden Einzelfälle.

Neuer Test mit den echten Schleifenmaßen (9 m hin, 6 m quer, reach 11 m):
vor dieser Korrektur lag die gesamte Markierung an der Schleife daneben,
danach vollständig darauf.

tools/extract/tests/test_marking_junction.py

@@ -155,6 +155,34 @@ def test_markierung_folgt_dem_geknickten_arm_nicht_der_ersten_richtung():
     assert sum(1 for a in anteile if a > 0.9) >= len(anteile) - 1, "fast jeder Balken muss klar auf der Fahrbahn liegen"
 
 
+def test_schleife_die_auf_sich_selbst_zurueckfuehrt_bekommt_keine_markierung_daneben():
+    """Zweite Korrektur zu Befund 3, am echten Netz entdeckt: Eine Schleife kann geradewegs von
+    ihrem Knoten weg- und auf demselben Weg wieder zurücklaufen (am echten Netz eine 21,63 m
+    lange Boulevard-Schleife, deren Punktliste den Hinweg exakt rückwärts wiederholt). Landet
+    reach nahe dieser Kehre, zeigt die Sehne vom Ursprung zu interpolate(reach) weiter nach außen,
+    obwohl die Kante dort längst umkehrt - mit dieser Zwischenstufe der Korrektur lag die gesamte
+    Markierung (Zebra und Haltelinie) an genau dieser Schleife vollständig neben der Fahrbahn
+    (0 % statt 100 %, nachgerechnet gegen die echten Koordinaten). Anker am tatsächlichen Punkt
+    plus Richtung aus dem letzten Teilstück von substring() behebt das.
+
+    Nachgebaut mit denselben Maßen wie am echten Netz (9 m hin, 6 m quer, macht 21,63 m Umweg;
+    reach=11 m, wie es der zweite Boulevard-Arm hier erzwingt).
+    """
+    spitze = [(0.0, 0.0), (9.0, -6.0), (0.0, 0.0)]
+    graph = Graph(
+        nodes=[Node((0.0, 0.0)), Node((-80.0, 0.0)), Node((9.0, -6.0))],
+        edges=[Edge(0, 1, [(0.0, 0.0), (-80.0, 0.0)], SECTION["boulevard"].corridor, "boulevard"),
+               Edge(0, 0, spitze, SECTION["boulevard"].corridor, "boulevard")],
+    )
+    halb = SECTION["boulevard"].carriageway / 2
+    fahrbahn = LineString(spitze).buffer(halb, cap_style="flat")
+    ziel = [(p, a) for p, a in junction_marks(graph, 0) if p.centroid.x > 1]   # nur die Schleife
+    assert ziel, "die Schleife muss Markierungen bekommen (zwei bordsteintragende Arme)"
+    for poly, art in ziel:
+        anteil = poly.intersection(fahrbahn).area / poly.area
+        assert anteil > 0.99, f"{art} liegt nur zu {anteil:.0%} auf der Schleifen-Fahrbahn"
+
+
 def test_kurzer_arm_an_breiter_kreuzung_bleibt_ohne_markierung():
     # reach = setback() kommt vom breitesten anliegenden Arm (hier Boulevard, halbe Fahrbahn 9 m)
     # und gilt für alle Zufahrten gleich - ein kurzer Arm reicht dann nicht mehr bis dorthin. Am