Re-port TCP to the flat platform

Bring TCP back online under the new flat platform architecture, mirroring
the SQLite port:

- platform/Tcp.roc: opaque `Stream :: Box(U64)` handle, 5 `host_*!` FFI
  declarations, and ergonomic wrappers (connect!/read_up_to!/read_exactly!/
  read_until!/read_line!/write!/write_utf8!) plus ConnectErr/StreamErr
  unions and parse_*/*_to_str helpers.
- src/lib.rs: 5 hosted_tcp_* host fns over a boxed BufReader<TcpStream>,
  using the same box helpers proven for SQLite (false for
  payload_contains_refcounted), with errors marshalled as Str.
- platform/main.roc: expose Tcp, import it, and append the hosted_tcp_*
  entries at the end of the hosted block to avoid renumbering glue types.
- src/roc_platform_abi.rs: regenerated (no existing aliases shifted).
- examples/tcp-client.roc: migrated from .todoroc to new-compiler syntax.
- ci/expect_scripts/tcp-client.exp + tcp_echo_server.py: self-contained
  expect test using a python3 echo server (no ncat dependency); wired into
  EXPECT_EXAMPLES in ci/all_tests.sh.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: lukewilliamboswell

ci/all_tests.sh

@@ -130,6 +130,7 @@ EXPECT_EXAMPLES=(
     "dir"
     "env-var"
     "sqlite-basic"
+    "tcp-client"
 )
 
 for roc_file in "${EXAMPLES_DIR}"*.roc; do

ci/expect_scripts/tcp-client.exp

@@ -0,0 +1,31 @@
+#!/usr/bin/expect
+
+# uncomment line below for debugging
+# exp_internal 1
+
+set timeout 7
+
+# Resolve the directory this script lives in so we can find the echo server.
+set script_dir [file dirname [info script]]
+
+# Start a self-contained echo server (avoids depending on ncat/nc being present).
+spawn python3 "$script_dir/tcp_echo_server.py"
+set server_id $spawn_id
+sleep 1
+
+spawn $env(EXAMPLES_DIR)tcp-client
+set client_id $spawn_id
+
+expect {
+    -i $client_id "Connected!\r\n" {
+        expect -i $client_id "> " {
+            send -i $client_id -- "Hi\r"
+            expect -i $client_id "< Hi\r\n" {
+                exit 0
+            }
+        }
+    }
+}
+
+puts stderr "\nExpect script failed: output was different from expected value. uncomment `exp_internal 1` to debug."
+exit 1

ci/expect_scripts/tcp_echo_server.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""Minimal single-connection TCP echo server used by tcp-client.exp.
+
+Listens on 127.0.0.1:8085, accepts one client, and echoes everything it
+receives straight back until the client disconnects. This keeps the TCP
+example's expect test self-contained (no dependency on `ncat`/`nc`).
+"""
+import socket
+
+with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
+    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    server.bind(("127.0.0.1", 8085))
+    server.listen(1)
+    conn, _ = server.accept()
+    with conn:
+        while True:
+            data = conn.recv(1024)
+            if not data:
+                break
+            conn.sendall(data)

examples/tcp-client.roc

@@ -0,0 +1,81 @@
+app [main!] { pf: platform "../platform/main.roc" }
+
+import pf.Tcp
+import pf.Stdout
+import pf.Stdin
+import pf.Stderr
+
+# Simple TCP client in Roc.
+#
+# Connects to a server on localhost:8085, reads user input from stdin, sends it
+# to the server, and prints the server's response — looping until end-of-input.
+#
+# To try it interactively, start an echo server in another terminal first:
+#
+#     $ ncat -e $(which cat) -l 8085
+#
+# then run this example.
+main! : List(Str) => Try({}, [Exit(I32), ..])
+main! = |_args|
+    match Tcp.connect!("127.0.0.1", 8085) {
+        Ok(stream) => {
+            _ = Stdout.line!("Connected!")
+            run!(stream)
+        }
+        Err(connect_err) => report_connect_err!(connect_err)
+    }
+
+## Read a line from stdin, send it to the server, print the response, repeat.
+run! : Tcp.Stream => Try({}, [Exit(I32), ..])
+run! = |stream| {
+    _ = Stdout.write!("> ")
+    match Stdin.line!({}) {
+        # No more input — exit cleanly.
+        Err(EndOfFile) => Ok({})
+        Err(StdinErr(_)) => Ok({})
+        Ok(out_msg) =>
+            match Tcp.write_utf8!(stream, "${out_msg}\n") {
+                Err(TcpWriteErr(err)) => report_stream_err!("writing", err)
+                Ok({}) =>
+                    match Tcp.read_line!(stream) {
+                        Err(read_err) => report_read_err!(read_err)
+                        Ok(in_msg) => {
+                            _ = Stdout.line!("< ${in_msg}")
+                            run!(stream)
+                        }
+                    }
+            }
+    }
+}
+
+report_connect_err! : Tcp.ConnectErr => Try({}, [Exit(I32), ..])
+report_connect_err! = |err| {
+    err_str = Tcp.connect_err_to_str(err)
+    _ = Stderr.line!(
+        \\Failed to connect: ${err_str}
+        \\
+        \\If you don't have anything listening on port 8085, run:
+        \\    $ nc -l 8085
+        \\
+        \\If you want an echo server you can run:
+        \\    $ ncat -e $(which cat) -l 8085
+    )
+    Ok({})
+}
+
+report_read_err! : [TcpReadErr(Tcp.StreamErr), TcpReadBadUtf8(_)] => Try({}, [Exit(I32), ..])
+report_read_err! = |err|
+    match err {
+        TcpReadErr(stream_err) => report_stream_err!("reading", stream_err)
+        TcpReadBadUtf8(_) => {
+            _ = Stderr.line!("Received invalid UTF-8 data")
+            Ok({})
+        }
+    }
+
+report_stream_err! : Str, Tcp.StreamErr => Try({}, [Exit(I32), ..])
+report_stream_err! = |action, err| {
+    err_str = Tcp.stream_err_to_str(err)
+    _ = Stderr.line!("Error while ${action}: ${err_str}")
+    Ok({})
+}