Initial commit: Naut-Torrent — from-scratch 10 GbE BitTorrent client

A maintainable, extensible BitTorrent client (C11, Linux/io_uring) targeting
10 GbE saturation. All torrent functionality is built from scratch; liburing
is the only linked third-party dependency on the data path.

Implements Phases 1-7 of the roadmap:
- core: page-aligned buffer pool, MPMC/Treiber queues, bitfields, worker pool
- crypto: SHA-1/256 (SHA-NI + scalar), Merkle (BEP-52), RC4 (MSE)
- bencode/metainfo: zero-copy parser, v1/v2/hybrid .torrent + magnet
- peer: sans-IO wire codec, MSE/PE handshake state machine, BEP-10, ut_metadata, PEX
- piece/storage: block-level multi-peer engine, rarest-first + endgame,
  per-file completion events + single-file relocate (move-as-you-finish)
- tracker/dht: HTTP + UDP (BEP-15) trackers, BEP-5 KRPC iterative lookup
- platform: io_uring reactor (SQPOLL, registered buffers, SEND_ZC)
- surface: versioned RPC, native plugin ABI, sandboxed Lua scripting, nautd/nautctl

Verified against libtorrent (single/multi/hybrid, MSE, magnet-via-DHT, swarm);
unit + interop tests green; ASan/UBSan/TSan clean. Scripting reference in
docs/scripting.md.

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

tests/unit/test_worker.c

@@ -0,0 +1,61 @@
+#include "naut/hash.h"
+#include "naut/worker.h"
+#include "test.h"
+
+#include <poll.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+
+#define JOBS 256
+
+typedef struct {
+    naut_job job;
+    uint8_t input[4096];
+    uint8_t digest[NAUT_SHA256_LEN];
+} hash_job;
+
+static void run_hash(naut_job *base) {
+    hash_job *job = base->context;
+    naut_sha256(job->input, sizeof job->input, job->digest);
+    base->result = NAUT_OK;
+}
+
+int main(void) {
+    naut_worker_pool *pool = naut_worker_pool_create(4, 512, -1);
+    CHECK(pool != NULL);
+    CHECK_EQ(naut_worker_threads(pool), 4);
+    CHECK(naut_worker_eventfd(pool) >= 0);
+
+    hash_job jobs[JOBS];
+    for (int i = 0; i < JOBS; i++) {
+        memset(jobs[i].input, i, sizeof jobs[i].input);
+        jobs[i].job.run = run_hash;
+        jobs[i].job.context = &jobs[i];
+        jobs[i].job.result = NAUT_ERR_AGAIN;
+        CHECK(naut_worker_submit(pool, &jobs[i].job));
+    }
+
+    int complete = 0;
+    while (complete < JOBS) {
+        struct pollfd pfd = {
+            .fd = naut_worker_eventfd(pool),
+            .events = POLLIN,
+        };
+        CHECK(poll(&pfd, 1, 5000) > 0);
+        uint64_t count;
+        (void)read(pfd.fd, &count, sizeof count);
+        naut_job *base;
+        while (naut_worker_complete(pool, &base)) {
+            hash_job *job = base->context;
+            uint8_t expected[NAUT_SHA256_LEN];
+            naut_sha256(job->input, sizeof job->input, expected);
+            CHECK(base->result == NAUT_OK);
+            CHECK(memcmp(job->digest, expected, sizeof expected) == 0);
+            complete++;
+        }
+    }
+    CHECK_EQ(complete, JOBS);
+    naut_worker_pool_destroy(pool);
+    TEST_MAIN_END();
+}