docs(tutorial): add zero-copy MemorySegment and streaming steps

Show the library's strong point — off-heap MemorySegment round-trip with no
copy or per-call allocation — plus incremental ZstdOutputStream/ZstdInputStream
for data that doesn't fit in memory.

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

Author: dfa1

docs/tutorial.md

@@ -36,5 +36,49 @@ The FFM API requires an explicit flag:
 java --enable-native-access=ALL-UNNAMED Demo.java
 ```
 
+## 4. Skip the heap: zero-copy with `MemorySegment`
+
+The `byte[]` round-trip above copies your data onto the heap on the way in and
+off it on the way out. When your bytes are **already off-heap** — an `mmap` slice,
+an arena buffer — that copy is pure waste. This is the library's strong point:
+the `MemorySegment` overloads hand zstd the segment address directly, so there is
+**no copy in, no copy out, and no per-call heap allocation** (hence no GC churn).
+
+```java
+try (Arena arena = Arena.ofConfined();
+     ZstdDecompressCtx dctx = new ZstdDecompressCtx()) {
+    MemorySegment frame = reader.mmapSlice();   // already native — never touches the heap
+    long n = Zstd.decompressedSize(frame);      // read the header, no copy
+    MemorySegment out = arena.allocate(n);      // this segment *is* the output buffer
+    dctx.decompress(out, frame);                // native → native
+}
+```
+
+In benchmarks this path allocates ~0 bytes/op regardless of payload size, while
+the `byte[]` path allocates the full output every call. See
+[docs/benchmarks.md](benchmarks.md) for numbers and [docs/zero-copy.md](zero-copy.md)
+for when it pays.
+
+## 5. Stream data that doesn't fit in memory
+
+For large or unbounded data, don't buffer the whole thing — wrap an ordinary
+`java.io` stream. `ZstdOutputStream` / `ZstdInputStream` compress and decompress
+incrementally, so memory stays flat no matter how big the payload.
+
+```java
+// compress a file as you write it
+try (var out = new ZstdOutputStream(Files.newOutputStream(packed), 9)) {
+    Files.copy(source, out);
+}
+
+// decompress as you read it back
+try (var in = new ZstdInputStream(Files.newInputStream(packed))) {
+    in.transferTo(Files.newOutputStream(restored));
+}
+```
+
+They are plain `OutputStream` / `InputStream` subclasses — drop them into any code
+that already speaks `java.io`.
+
 That's the whole loop. From here, pick a [how-to guide](../README.md#how-to-guides)
 for your actual task, or browse the [reference](../README.md#reference).