fix: exhaustive Statement match for concurrency variants (restores build) (#56)

## Problem

The `Statement` enum in `src/ast/mod.rs` gained worker/concurrency
variants
(`WorkerSpawn`, `SendMessage`, `ReceiveMessage`, `AwaitWorker`,
`CancelWorker`) but several `match stmt` sites were never updated. This
produced `error[E0004]` non-exhaustive match and broke `cargo build`
(the `woke` binary failed to compile; `cargo build --lib` exited 101).

## Sites fixed

Four match sites were missing the new variants:

1. **`src/ast/visitor.rs` — `walk_statement`** (missing `SendMessage`,
   `ReceiveMessage`, `AwaitWorker`, `CancelWorker`):
`SendMessage` now recurses into its `message` expression, exactly like
the neighbouring expr-bearing arms (`Expression`, `Assignment`, …). The
three name-only variants are leaves, so they join the existing leaf arm
   alongside `WorkerSpawn`/`Complain`/`Break`/`Continue`.

2. **`src/interpreter/mod.rs` — `execute_statement`** (missing
   `SendMessage`, `ReceiveMessage`, `AwaitWorker`, `CancelWorker`;
   `WorkerSpawn` was already handled):
   There is no worker-name-addressed messaging runtime — `WorkerSpawn`'s
   own inline comment states workers communicate via channels created in
   the main scope, and workers run detached. Rather than fake a no-op,
   each of the four variants returns a clear, actionable `RuntimeError`
(built with `RuntimeError::new`, consistent with the `Complain` arm and
   the break/continue-outside-loop guards), pointing the user at the
   channel-based pattern.

3. **`src/sexpr.rs` — `stmt_to_sexpr` and `stmt_to_json`** (both missing
   all four variants): real serialization added for each, matching the
   style of neighbouring arms (`(send :to "..." <expr>)`,
   `(receive :from "...")`, `(await-worker "...")`,
   `(cancel-worker "...")`; and the equivalent JSON objects).

No silent `_ => {}` catch-all was introduced anywhere, so any future
`Statement` variant will continue to surface as a compile-time error.

## Build verification

```
$ cargo build --lib
warning: `wokelang` (lib) generated 14 warnings
    Finished `dev` profile [unoptimized + debuginfo] target(s)

$ cargo build
warning: `wokelang` (bin "woke-dap") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s)

$ cargo test --no-run
  Executable unittests src/bin/woke-lsp.rs (...)
  Executable tests/codegen_test.rs (...)
  Executable tests/e2e_full_pipeline_test.rs (...)
  Executable tests/lsp_handler_test.rs (...)
  Executable tests/lsp_integration_test.rs (...)
  Executable tests/property_test.rs (...)
```

All three complete with no errors (pre-existing warnings only).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: hyperpolymath <hyperpolymath@users.noreply.github.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: hyperpolymath

src/ast/visitor.rs

@@ -74,7 +74,10 @@ pub fn walk_statement<V: Visitor>(v: &mut V, stmt: &Statement) {
             for s in &c.body { v.visit_statement(s); }
         }
         Statement::Expression(e) => v.visit_expr(&e.node),
-        Statement::WorkerSpawn(_) | Statement::Complain(_)
+        Statement::SendMessage(s) => v.visit_expr(&s.message.node),
+        Statement::WorkerSpawn(_) | Statement::ReceiveMessage(_)
+        | Statement::AwaitWorker(_) | Statement::CancelWorker(_)
+        | Statement::Complain(_)
         | Statement::Break(_) | Statement::Continue(_) => {}
         Statement::EmoteAnnotated(e) => v.visit_statement(&e.statement),
         Statement::Decide(d) => {

src/interpreter/mod.rs

@@ -515,6 +515,30 @@ impl Interpreter {
                 Ok(Value::Unit)
             }
 
+            Statement::SendMessage(send) => Err(RuntimeError::new(format!(
+                "Worker-addressed message passing is not implemented: cannot `send` to worker '{}'. \
+                 Use a channel created in the main scope and pass it to the worker instead.",
+                send.target
+            ))),
+
+            Statement::ReceiveMessage(recv) => Err(RuntimeError::new(format!(
+                "Worker-addressed message passing is not implemented: cannot `receive` from worker '{}'. \
+                 Use a channel created in the main scope and pass it to the worker instead.",
+                recv.source
+            ))),
+
+            Statement::AwaitWorker(await_worker) => Err(RuntimeError::new(format!(
+                "Awaiting a worker by name is not implemented: cannot `await` worker '{}'. \
+                 Workers run detached; synchronise via a channel created in the main scope.",
+                await_worker.worker_name
+            ))),
+
+            Statement::CancelWorker(cancel) => Err(RuntimeError::new(format!(
+                "Cancelling a worker by name is not implemented: cannot `cancel` worker '{}'. \
+                 Workers run detached and cannot currently be cancelled.",
+                cancel.worker_name
+            ))),
+
             Statement::Complain(complain) => Err(RuntimeError {
                 message: complain.message.clone(),
             }),

src/sexpr.rs

@@ -331,6 +331,20 @@ fn stmt_to_sexpr(stmt: &Statement, out: &mut String, indent: usize) {
         Statement::WorkerSpawn(w) => {
             out.push_str(&format!("(spawn-worker \"{}\")", w.worker_name));
         }
+        Statement::SendMessage(s) => {
+            out.push_str(&format!("(send :to \"{}\" ", s.target));
+            expr_to_sexpr(&s.message.node, out, indent + 2);
+            out.push(')');
+        }
+        Statement::ReceiveMessage(r) => {
+            out.push_str(&format!("(receive :from \"{}\")", r.source));
+        }
+        Statement::AwaitWorker(a) => {
+            out.push_str(&format!("(await-worker \"{}\")", a.worker_name));
+        }
+        Statement::CancelWorker(c) => {
+            out.push_str(&format!("(cancel-worker \"{}\")", c.worker_name));
+        }
         Statement::Complain(c) => {
             out.push_str(&format!("(complain \"{}\")", c.message));
         }
@@ -710,6 +724,23 @@ fn stmt_to_json(stmt: &Statement) -> serde_json::Value {
             "type": "spawn_worker",
             "name": w.worker_name
         }),
+        Statement::SendMessage(s) => serde_json::json!({
+            "type": "send_message",
+            "target": s.target,
+            "message": expr_to_json(&s.message.node)
+        }),
+        Statement::ReceiveMessage(r) => serde_json::json!({
+            "type": "receive_message",
+            "source": r.source
+        }),
+        Statement::AwaitWorker(a) => serde_json::json!({
+            "type": "await_worker",
+            "name": a.worker_name
+        }),
+        Statement::CancelWorker(c) => serde_json::json!({
+            "type": "cancel_worker",
+            "name": c.worker_name
+        }),
         Statement::Complain(c) => serde_json::json!({
             "type": "complain",
             "message": c.message