host: review fixes for cargo.build, the test runner, the console, and main; tests for every PROTOCOL.md rule

cargo.build and the runner (review T22R): builds use the network again;
core.unlock and core.notify in order under the runner; quiet test
output; manifest preparation keeps [workspace], target tables, renamed
and optional entries; cargo.rpc.discover; -32004 with data.output;
retention of 10 builds; light, empty test worlds with an in-memory
journal; only CARGO_/RUST_/SAUSAGE_ variables; stdin is null; the runner
through --config. A compile cache that cannot be created is not fatal.
Activation replaces plugin.wasm without a gap.

Console and main: init ships the workspace Cargo.lock and creates the
world atomically; each console command runs in its own task, so ps,
stop, and kill work during a slow call; SAUSAGE_HEADLESS; the terminal
mode is restored; signals during boot; chat text is not taken as a
command.

Tests: 20 more tests for PROTOCOL.md sections 2 to 10; the cargo tests
choose the libtest binary from cargo's JSON output and time out.

cli/tests/plugins/probe/src/main.rs

@@ -324,9 +324,75 @@ fn notification_child(lines: &mut Lines) -> Value {
     }
     json!(count)
 }
+fn batch(lines: &mut Lines) -> Value {
+    send(
+        json!([{"jsonrpc":"2.0","method":"probe.write","params":{"path":"/state/batch","text":"bad"}}]),
+    );
+    outgoing_call(
+        &json!({"method":"probe.echo","params":{"barrier":true}}),
+        lines,
+    );
+    json!(!std::path::Path::new("/state/batch").exists())
+}
+fn late_answer(request: &Value, lines: &mut Lines) {
+    send(json!({"jsonrpc":"2.0","id":request["id"],"result":42}));
+    send(json!({"jsonrpc":"2.0","id":request["id"],"result":99}));
+    for _ in lines {}
+}
+fn nested_environment(lines: &mut Lines) -> Value {
+    let child = outgoing_call(&json!({"method":"probe.env","params":{}}), lines);
+    json!({"caller":std::env::var("SAUSAGE_PID").unwrap(),"child":child})
+}
+fn forgotten(request: &Value, lines: &mut Lines) {
+    std::fs::write("/state/forgotten", environment().to_string()).unwrap();
+    serve(request, lines);
+}
+fn forget(lines: &mut Lines) -> Value {
+    send(
+        json!({"jsonrpc":"2.0","method":"core.call","params":{"method":"probe.forgotten","params":{},"detach":true}}),
+    );
+    while !std::path::Path::new("/state/forgotten").exists() {
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    send(json!({"jsonrpc":"2.0","id":"barrier","method":"probe.echo","params":{}}));
+    let response = receive(lines);
+    assert_eq!(
+        response["id"], "barrier",
+        "a forgotten call must not send a result"
+    );
+    environment()
+}
+fn tree(request: &Value, lines: &mut Lines) {
+    let depth = request["params"]["depth"].as_u64().unwrap();
+    if depth > 0 {
+        outgoing_call(
+            &json!({"method":"probe.tree","params":{"depth":depth-1}}),
+            lines,
+        );
+    }
+    send(
+        json!({"jsonrpc":"2.0","id":request["id"],"result":std::env::var("SAUSAGE_PID").unwrap()}),
+    );
+    busy();
+}
 fn dispatch(request: &Value, lines: &mut Lines) -> Option<Value> {
     let params = &request["params"];
     let result = match request["method"].as_str().unwrap() {
+        "batch" => batch(lines),
+        "nested_environment" => nested_environment(lines),
+        "forget" => forget(lines),
+        "forgotten" => {
+            forgotten(request, lines);
+            return None;
+        }
+        "tree" => {
+            tree(request, lines);
+            return None;
+        }
+        "late_answer" => {
+            late_answer(request, lines);
+            return None;
+        }
         "invalid_stderr" => {
             io::stderr().write_all(&[255, 10]).unwrap();
             eprintln!("after invalid UTF-8");