Streets: sidewalks, road curves, junctions and roundabouts

Roads take sidewalks (none, both, left, right): 12 cm high paving with
kerb faces drawn where they face the viewer. Road curve (radius, angle,
left/right) carries a street round a bend; centre lines are true arcs
when cut and offset, so curve joints are seamless. A road ending on
another road's centre line opens that road's kerb and sidewalk (T
junction); two roads ending at one corner close it. Roundabout: ring
radius and width, one or two lanes, up to four arms with flared kerbs,
splitter islands, give-way lines on the entry side (traffic on the left
or right) and a central island with apron.

Studio: a road run drawn corner by corner gets a curve in each corner
(prefab meta `corner`). Tooltips list the streets each one meets.
Engine: open `polyline` primitive (Prim::Poly open) so dashes run on
round curves. examples/streets and a Streets demo in the web Studio;
MCP guidance, docs. ROADMAP: backlog 5-7 done; multi-select and the
hosted copy marked done.

Tests: Rust 72, Studio 113, web 95.

docs/SCRIPTING.md

@@ -88,6 +88,7 @@ shaded automatically by face direction.
 | `flat(poly or polys, z, cls[, id])` | flat polygon(s); later ones cut holes |
 | `open(a, b, [[u0, u1, z0, z1], …], cls[, id])` | windows / doors on the face a→b (outward normal on the right) |
 | `lines(segs, z, cls)`, `disc(cx, cy, z, r, cls[, id])` | markings |
+| `polyline(lines, z, cls)` | open lines through plan points at height z (or 3D points): a dashed line stays one dash run round a curve |
 | `circle(x, y, z, r_px, cls[, dx, dy])`, `stem(x, y, z0, z1, w_px, cls)` | screen-space details (crowns, poles) |
 | `person(x, y, z[, cls])`, `sit(x, y, z, cls)`, `head(x, y, z, r)`, `led(x, y, z[, cls])` | figures |
 | `puffs(x, y, z[, kind[, n, dur]])`, `fan(x, y, z, r)` | animated steam / smoke / fans |
@@ -153,6 +154,34 @@ through the document, like house parts:
   Poses pointing away from the viewer are drawn before the base, the others
   after it.
 
+## Streets
+
+`road`, `road_curve` and `roundabout` (stdlib/streets.rhai; `road` lives in
+ground.rhai) meet by their centre lines:
+
+- Each street is a centre line (a polyline or a true arc) with the
+  carriageway `d` wide around it; `walk` (none, both, left, right, looking
+  along local +x) adds sidewalks `walk_w` wide behind the kerbs: 12 cm high
+  paving with the kerb face drawn where it is turned to the viewer. Arcs stay
+  arcs when cut and offset, so a curve meets a straight road exactly.
+- End to end (a curve continuing a road, a road continuing a roundabout arm)
+  the pieces carry on, overlapping by 4 cm so no hairline shows.
+- A street ending on a road's centre line makes a T: the road leaves a gap in
+  its kerb and sidewalk on that side, the street stops its centre line and
+  kerbs at the road's edge and its sidewalks at the road's sidewalk.
+- Two roads ending at one point at right angles close the corner: both run
+  over it, the inner sidewalks stop at the other road's kerb, the outer ones
+  go round.
+- A roundabout's arms end `r + arm_len` from its centre, along its local
+  +x, +y, -x, -y. Its kerbs flare into the ring with a fillet; splitter
+  islands and give-way lines sit on the entry side for `drive` left or right.
+- The prefab meta `corner: "road_curve"` on `road` tells the Studio to round
+  each corner of a road run with a curve (up to its default radius, less
+  where the pieces next to a corner are short).
+- `street_ends(o)`, `street_join(o, end, others)`, `street_gaps(o, others)`
+  and `street_path(o, line, j0, j1, gaps)` are there for your own street
+  prefabs; tooltips list the streets each one meets (`Meets`).
+
 ## House parts
 
 `house_wall`, `window`, `door`, `floor`, `roof`, `stairs` and the furniture