feat(core): the command line's network commands ping, host, nslookup, arp and netstat after Java, measured against Java

TerminalRun types lines into Java's command line on terminal-net at set
times; the engine types the same lines. New in the engine: an ICMP echo
in a program's thread (the first ICMP message after the send, whatever
it is), Java's route choice, the ARP table with Java's broadcast row, DNS
in a program's thread, ICMP broadcasts of a node's own network, and an
ARP wait that ends after what else happens at that millisecond.

Departures from Java: an echo is answered from the address asked
(RFC 792), network unreachable carries the packet with its sender, ping
names the host and takes only -b before it, arp and netstat list in the
order learned, netstat lists a UDP server's listening socket only.

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

tools/java-oracle/README.md

@@ -793,3 +793,71 @@ Gemessen (01.10.2026):
   Pfad an den Arbeitsordner, `rm /` löscht den Arbeitsordner und meldet
   Erfolg; `mv` auf die Datei selbst (auch in anderer Schreibweise) löscht
   sie.
+
+## Befehlszeile, Netzbefehle (F3.4b)
+
+`TerminalRun` tippt Zeilen in Javas `Terminal` auf den Rechnern von
+`terminal-net` (LAN 192.168.0.0/24 mit Client .20, DNS-Server .10 ohne
+Gateway, .30, .31, Router .1/10.0.0.1, dahinter 10.0.0.2 mit einem
+DNS-Server, den es nicht gibt), zu festen Zeiten und so, wie das Fenster sie
+übergibt (`terminalEingabeAuswerten`); `^C` ist Strg+C (`setInterrupt`).
+Geschrieben werden je Karte die Frames samt Javas Tabellen, je Rechner was
+die Befehlszeile sagt (Texte und Laufmarken) mit der Zeit, und die getippten
+Zeilen mit ihren Zeiten, die der Test des Kerns ebenso tippt. Die JVM läuft
+deutsch.
+
+Gemessen (02.10.2026):
+
+* `ping`: vier Echos, je eines pro Sekunde ab dem Senden des vorigen; die
+  Zeit zählt ab vor dem ARP (473 ms im LAN mit ARP, dann 223 ms; über den
+  Router 673 und 334 ms, TTL 63). Gewartet wird nach dem Senden eine RTT
+  (hier 2750 ms) auf die *erste* ICMP-Nachricht, gleich welche; alles außer
+  der Antwort mit der Sequenznummer ist „Timeout!“, und das nächste Echo geht
+  sofort. Ohne ARP-Antwort legt sich der Rechner selbst „Host Unreachable“
+  hin (je Echo zwei ARP-Anfragen, 5,5 s); hinter dem Router fragt dieser
+  seine ARP-Anfragen nacheinander ab, so beantwortet das dritte Echo die
+  Meldung zum ersten. Ohne Route am Router kommt „Network Unreachable“
+  sofort, viermal in 900 ms. Strg+C wirkt vor dem nächsten Echo, die
+  Statistik zählt die gesendeten; ein danach getippter bekannter Befehl
+  hebt es auf (`setInterrupt(false)` beim Übergeben), ein unbekannter nicht.
+  Einen unbekannten Befehl meldet das Fenster sofort, auch während ein
+  anderer läuft.
+* Broadcast: ohne `-b` „nicht unterstützt“ (auch 255.255.255.255 über die
+  Standardroute, Maske 0.0.0.0); mit `-b` geht das Echo mit TTL 1 an
+  FF:FF:FF:FF:FF:FF, alle im Netz antworten (auch der Router), jeder fragt
+  dazu per ARP nach dem Absender. Welche Antwort zuerst kommt, ist ein
+  Wettlauf der Threads. Ein gerichteter Broadcast aus einem anderen Netz
+  (10.0.0.2 an 192.168.0.255) wird am Router verworfen.
+* Eigene Adresse: Javas Route geht über 127.0.0.1, die Antwort kommt „From
+  127.0.0.1“; ebenso für `localhost` und 127.0.0.1, ohne Frame.
+* Ferne Adresse eines Routers: die Antwort kommt von der nahen Karte
+  („From 192.168.0.1“ für `ping 10.0.0.1`).
+* Fehler Javas: in der Statistik und bei „Timeout!“ steht der erste Parameter
+  statt des Hosts (`--- -b Paketstatistik`); jedes erste Wort gilt als `-b`
+  (`ping -x 192.168.0.31` pingt). „Network Unreachable“ vom Router bettet ein
+  halb gebautes Paket ein (`sender=null`, TTL 63).
+* `host`: A, dann MX, Namen mit Punkt am Ende; „nicht aufgelöst“ erst nach
+  beiden Anfragen (auch MX allein zählt); `localhost` ohne Anfrage. Ohne erreichbaren DNS-Server
+  nach fünf RTT „Zeitüberschreitung“, bei `ping` mit „ (DNS)“ und ohne
+  Laufmarken. Ohne eingetragenen DNS-Server sofort „nicht aufgelöst“.
+* `nslookup`: Server und Adresse (127.0.0.1 für `localhost`), dann nur der
+  Antwortteil; ohne Treffer nur der Kopf. Ohne Parameter die Hilfe ohne
+  Laufmarken (`host` mit).
+* `arp`: Javas Tabelle ist eine `HashMap` mit der Zeile 255.255.255.255,
+  die jedes Zurücksetzen (`-d`) neu anlegt; `-a` zeigt eine Zeile, `-d` mit
+  Adresse löscht sie und zeigt dann die Tabelle; unbekannte Optionen und
+  `-a`/`-d` mit etwas anderem als einer Adresse zeigen die Tabelle. `arp -d
+  255.255.255.255` entfernt auch die Broadcast-Zeile, bis `arp -d`.
+* `netstat`: TCP, dann UDP, je Socket die lokale Adresse nach der Route zur
+  Gegenstelle; ein Server mit `0.0.0.0` und `-:-` in LISTEN, darunter seine
+  Verbindungen; eine getrennte Verbindung steht beim Client in `TIME_WAIT`,
+  beim Server ist sie ausgetragen. Javas UDP-Server behält für jede je beantwortete Adresse und
+  jeden Port einen Socket (`CONNECTED`), dessen Arbeiter für immer wartet.
+  Die Reihenfolge ist die einer `HashMap` bzw. `Hashtable`.
+* Javas `waitForIcmpResponse` verpasst sein Aufwecken, wenn die Antwort
+  schon da ist, bevor es wartet (ein Wettlauf der Threads: Echo an sich
+  selbst, das „Host Unreachable“, das sich ein Rechner selbst hinlegt), und
+  wartet dann eine volle RTT. Eine Aufnahme damit (ein Ping an sich selbst
+  über 1 s, mehr als 6 s zwischen zwei Timeouts ins Leere) wird wiederholt;
+  ebenso eine unter Last (andere Sitzungen auf dem Rechner: die erste
+  ARP-Runde dauert dann knapp 300 statt 225 ms).