feat(core): sends return at once and go through Java's transport thread

A send hands its frame to the card and returns, as in Java; the frames
travel while the clock advances. Swift's send ran the network until every
frame had arrived; the option swiftSends keeps that for the Swift
comparison. Waiting calls (TCP connect, acknowledgement) now run event by
event until the answer instead of to the timeout.

UDP and TCP send through a thread per node and protocol (Java's
TransportProtokoll): one segment after the other; while IP waits for ARP,
the next send blocks and a segment from an event queues behind it. Senders
that wait take their turns in the order they came (a fair lock; Java's
leaves the order to chance).

All four ArpRun stories now match Java FILIUS, including when each call
returns. Tests let frames arrive explicitly with letFramesArrive.

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

packages/core/test/fixtures.ts

@@ -48,3 +48,17 @@ export function startedEngine(
 export function uuid(suffix: number): Id {
   return `00000000-0000-0000-0000-${suffix.toString(16).toUpperCase().padStart(12, '0')}`;
 }
+
+const FRAME_EVENTS = new Set(['ethernetLinkDeparture', 'ethernetLinkDelivery', 'remoteLinkDelivery', 'arpAnswered']);
+
+/**
+ * Advances until every frame in flight has arrived — what Swift's send did
+ * by itself; the engine's send returns at once, as Java's.
+ */
+export function letFramesArrive(engine: NetworkRuntimeEngine): void {
+  const inFlight = () =>
+    engine.state.pendingEvents.filter((event) => FRAME_EVENTS.has(event.kind.kind)).map((event) => event.deadlineMilliseconds);
+  for (let deadlines = inFlight(); deadlines.length > 0; deadlines = inFlight()) {
+    engine.handle({ type: 'advance', toMilliseconds: Math.min(...deadlines) });
+  }
+}