fix(extract): Fahrbahn, Restflächen und Brücken sind begehbar, nicht nur der Gehweg

Korrektur eines Fehlers im Plantext, nicht in der vorigen Umsetzung: "begehbar" ist in
src/ui/mapMath.js (nearestWalkable()/landingFor()) als "Kollisionsboden ohne Gebäude"
definiert, nicht als Fußgängerzone. Fahrbahn ist die kollidierende Mulde, Restflächen
liegen auf der Bodenplatte, Brücken haben ihr eigenes Deck - alle drei tragen wie die
Landplatte und der Gehweg. Nur Gebäude sperren; Wasser bleibt gesperrt, weil nichts
darüber gemalt wird. Ein Klick auf eine Straße oder einen Damm über Wasser landet damit
wieder auf ihr, statt ins Nichts zu greifen.

chunk["bridges"] wird dafür wieder gelesen und zusätzlich im Kartenbild in BRIDGE
gezeichnet, nach der Fahrbahn, damit eine Brücke als Brücke zu sehen ist und nicht als
Straße im Wasser.

test_walkable_mask_counts_only_ground_with_collision und
test_walkable_mask_blocks_buildings_and_water zurückgestellt; ein neuer Test sichert die
Brückenfarbe im Kartenbild. test_gehweg_ist_begehbar_die_fahrbahn_nicht sagte nach der
Korrektur nicht mehr die Wahrheit über sich selbst - Fahrbahn ist jetzt auch begehbar -
und ist umbenannt in test_gehweg_und_fahrbahn_sind_beide_begehbar. Der Skip-Grund von
test_committed_map_files_match_the_committed_chunks nennt jetzt die Bedingung fürs
Entfernen statt einer Aufgabennummer.

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

tools/extract/overview.py

@@ -33,6 +33,7 @@ SIDEWALK = (206, 202, 194)
 SURFACE = {"sand": (226, 210, 150), "park": (120, 160, 90), "urban": (176, 176, 172),
            "field": (96, 176, 78), "court": (92, 138, 118), "pool": (70, 150, 220), "parking": ROAD}
 PATH = (226, 216, 190)
+BRIDGE = (196, 92, 92)
 PALM = (40, 190, 70)
 OUTLINE = (30, 30, 30)
 TALL = 120.0                     # Meter, ab der ein Gebäude die hellste Färbung bekommt
@@ -78,24 +79,25 @@ def _load_chunks(out_dir: Path) -> list[dict]:
     return [json.loads(f.read_text()) for f in sorted(out_dir.glob("chunk_*.json"))]
 
 
-def _paint_layers(img, chunks, scale, *, land, surface, sidewalk, lots, road, building,
+def _paint_layers(img, chunks, scale, *, land, surface, sidewalk, lots, road, bridge, building,
                   outline=None, palm=None, path=None) -> dict:
     """Ebene für Ebene über alle Chunks, damit nichts von einem Nachbarchunk überdeckt wird.
 
     surface ist eine Funktion der Belagsart, building eine Funktion der Gebäudehöhe; beide können
     None liefern und die Fläche so aussparen (path=None lässt ebenso die ganze Ebene aus). land,
-    sidewalk, lots und road sind dagegen an jedem Aufrufort eine feste Füllung — in der
-    Begehbarkeitsmaske ausdrücklich WALKABLE oder BLOCKED, denn Fahrbahn und Restflächen sollen dort
-    aktiv sperren statt nur wirkungslos zu bleiben: dort fährt Verkehr, kein Fußgänger soll landen.
-    Reihenfolge von hinten nach vorn: Land, Beläge, Wege, Gehweg, Restflächen, Fahrbahn, Gebäude —
-    jede Ebene deckt die vorige ab.
+    sidewalk, lots, road und bridge sind dagegen an jedem Aufrufort eine feste Füllung: in der
+    Begehbarkeitsmaske für alle fünf WALKABLE, denn nach der Bedeutung in nearestWalkable()
+    (src/ui/mapMath.js) ist ein Pixel begehbar, wenn seine Fläche Kollisionsboden ohne Gebäude ist —
+    und Fahrbahn (die kollidierende Mulde), Restflächen (auf der Bodenplatte) und Brücken (eigenes
+    Deck) haben Kollision, Beläge und Wege dagegen nicht.
+    Reihenfolge von hinten nach vorn: Land, Beläge, Wege, Gehweg, Restflächen, Fahrbahn, Brücken,
+    Gebäude — jede Ebene deckt die vorige ab. Brücken zuletzt, damit eine Brücke als Brücke zu sehen
+    ist und nicht als Straße im Wasser: ihre Fahrbahn steckt schon in carriageway an derselben Stelle.
 
     chunk["markings"] wird hier nie gelesen: bei einem Pixel je Meter wäre eine 10 cm breite Linie
-    ein Drittel Pixel und damit nur Rauschen. chunk["bridges"] ebenfalls nicht mehr: ihre Fahrbahn
-    steckt schon in carriageway, ihr begehbarer Streifen im sidewalk — eine eigene Brücken-Regel
-    braucht es hier nicht mehr.
+    ein Drittel Pixel und damit nur Rauschen.
     """
-    stats = {"land": 0, "gehweg": 0, "restflaechen": 0, "strassen": 0, "gebaeude": 0, "palmen": 0}
+    stats = {"land": 0, "gehweg": 0, "restflaechen": 0, "strassen": 0, "bruecken": 0, "gebaeude": 0, "palmen": 0}
     placed = [(chunk, chunk["origin"][0], -chunk["origin"][1]) for chunk in chunks]
     for chunk, ox, oy in placed:
         for rings in chunk["land"]:
@@ -122,6 +124,10 @@ def _paint_layers(img, chunks, scale, *, land, surface, sidewalk, lots, road, bu
         for item in chunk["carriageway"]:
             _draw(img, item["poly"], ox, oy, road, scale=scale)
             stats["strassen"] += 1
+    for chunk, ox, oy in placed:
+        for item in chunk["bridges"]:
+            _draw(img, item["poly"], ox, oy, bridge, scale=scale)
+            stats["bruecken"] += 1
     for chunk, ox, oy in placed:
         for item in chunk["buildings"]:
             _draw(img, item["poly"], ox, oy, building(item["height"]), outline=outline, scale=scale)
@@ -139,8 +145,8 @@ def render(out_dir: Path, dst: Path) -> dict:
     size = int((SLICE["x1"] - SLICE["x0"]) * SCALE)
     img = Image.new("RGB", (size, size), WATER)
     stats = _paint_layers(img, _load_chunks(out_dir), SCALE, land=LAND, surface=SURFACE.__getitem__,
-                          sidewalk=SIDEWALK, lots=ROAD, road=ROAD, building=_building_shade,
-                          outline=OUTLINE, palm=PALM, path=PATH)
+                          sidewalk=SIDEWALK, lots=ROAD, road=ROAD, bridge=BRIDGE,
+                          building=_building_shade, outline=OUTLINE, palm=PALM, path=PATH)
     dst.parent.mkdir(parents=True, exist_ok=True)
     img.save(dst)
     return stats
@@ -149,19 +155,19 @@ def render(out_dir: Path, dst: Path) -> dict:
 def _walkable_mask(chunks: list[dict], width_m: int) -> Image.Image:
     """Begehbarkeitsmaske mit WALKABLE_SCALE, vorsichtig aus einem 1-m-Raster verdichtet.
 
-    Begehbar heißt: die Figur steht dort auf Kollision. Das tragen nur die Landplatte und der
-    Gehweg. Fahrbahn und Restflächen sperren aktiv, auch über der Landplatte — dort fährt Verkehr,
-    kein Fußgänger soll dort landen —, und Gebäude sind geschlossene Kästen. Für eine Brücke gibt es
-    keine eigene Regel mehr: ihr begehbarer Streifen liegt im Gehweg, der dort die Landplatte
-    ersetzt, ihre Fahrbahn sperrt wie jede andere. Ein Maskenpixel gilt nur als begehbar, wenn jeder
-    Quadratmeter darunter frei ist. Ein nur teilweise freier Pixel setzte die Figur sonst in eine
-    Wand oder vor die Kaimauer ins Wasser; an den ausgelieferten Daten traf das 4,3 % der Klicks
-    auf Gebäude. Die Landung erfolgt in der Pixelmitte (nearestWalkable in src/ui/mapMath.js),
-    also mindestens 2 m von jedem gesperrten Quadratmeter entfernt.
+    Begehbar heißt hier wörtlich, was nearestWalkable() in src/ui/mapMath.js daraus liest: die ganze
+    Fläche eines Pixels ist Kollisionsboden ohne Gebäude. Das sind Landplatte, Gehweg, Fahrbahn,
+    Restflächen und Brückendecks — alle fünf tragen für sich, auch eine Brücke über Wasser ganz ohne
+    Landplatte darunter. Beläge und Wege bleiben reine Auflagen ohne eigene Kollision, Gebäude sind
+    geschlossene Kästen, und Wasser bleibt gesperrt, weil dort nichts gemalt wird. Ein Maskenpixel
+    gilt nur als begehbar, wenn jeder Quadratmeter darunter frei ist. Ein nur teilweise freier Pixel
+    setzte die Figur sonst in eine Wand oder vor die Kaimauer ins Wasser; an den ausgelieferten Daten
+    traf das 4,3 % der Klicks auf Gebäude. Die Landung erfolgt in der Pixelmitte (nearestWalkable in
+    src/ui/mapMath.js), also mindestens 2 m von jedem gesperrten Quadratmeter entfernt.
     """
     fine = Image.new("L", (width_m, width_m), BLOCKED)
-    _paint_layers(fine, chunks, 1.0, land=WALKABLE, surface=lambda _kind: None,
-                  sidewalk=WALKABLE, lots=BLOCKED, road=BLOCKED, building=lambda _height: BLOCKED)
+    _paint_layers(fine, chunks, 1.0, land=WALKABLE, surface=lambda _kind: None, sidewalk=WALKABLE,
+                  lots=WALKABLE, road=WALKABLE, bridge=WALKABLE, building=lambda _height: BLOCKED)
     step = round(1 / WALKABLE_SCALE)
     size = width_m // step
     cells = np.asarray(fine).reshape(size, step, size, step)
@@ -176,7 +182,7 @@ def render_map(out_dir: Path, dst_dir: Path) -> dict:
 
     picture = Image.new("RGB", (int(width_m * MAP_SCALE),) * 2, WATER)
     _paint_layers(picture, chunks, MAP_SCALE, land=LAND, surface=SURFACE.__getitem__,
-                  sidewalk=SIDEWALK, lots=ROAD, road=ROAD, building=_building_shade,
+                  sidewalk=SIDEWALK, lots=ROAD, road=ROAD, bridge=BRIDGE, building=_building_shade,
                   outline=OUTLINE, path=PATH)
 
     walkable = _walkable_mask(chunks, width_m)