avoid generating duplicate stream and future constructors

Previously, we used the payload type to avoid generating duplicates, but that
doesn't work reliably because `wit-parser` does not necessarily deduplicate
types involving aliases, such as the following example:

```
interface types {
  variant foo {
    bar,
    baz
  }
}

interface use-types-a {
  use types.{foo};

  test: func() -> future<result<foo>>;
}

interface use-types-b {
  use types.{foo};

  test: func() -> future<result<foo>>;
}
```

When targetting a world which imports and/or exports both `use-types-a` and
`use-types-b`, we'll end up with distinct type IDs for `result<foo>`.

This commit switches to using the mangled name of the payload type for
deduplication.  That's not 100% reliable either, since the name mangling code
does not yet guarantee every distinct type will have a unique mangled name, so
there's more work to do there, but this at least unblocks using
`wasi:cli@0.3.0-rc-2026-02-09`, which has a similar pattern to the above WIT
example.

Note that this is awkward to test given our current test infra, but #205 will
cover it once it's merged.

Author: dicej

src/summary.rs

@@ -1742,10 +1742,14 @@ class {camel}(Protocol):
                     | TypeDefKind::Result(_)
                     | TypeDefKind::Handle(_) => (None, Vec::new()),
                     TypeDefKind::Stream(ty) => {
-                        let code = if stream_payloads.contains(ty) {
+                        let snake = ty
+                            .map(|ty| names.mangle_name(ty))
+                            .unwrap_or_else(|| "unit".into());
+
+                        let code = if stream_payloads.contains(&snake) {
                             None
                         } else {
-                            stream_payloads.insert(ty);
+                            stream_payloads.insert(snake.clone());
 
                             Some(if let Some(Type::U8 | Type::S8) = ty {
                                 if stub_runtime_calls {
@@ -1766,9 +1770,6 @@ def byte_stream() -> tuple[ByteStreamWriter, ByteStreamReader]:
                                     )
                                 }
                             } else {
-                                let snake = ty
-                                    .map(|ty| names.mangle_name(ty))
-                                    .unwrap_or_else(|| "unit".into());
                                 let camel = ty
                                     .map(|ty| names.type_name(ty, &seen, None))
                                     .unwrap_or_else(|| "None".into());
@@ -1795,14 +1796,15 @@ def {snake}_stream() -> tuple[StreamWriter[{camel}], StreamReader[{camel}]]:
                         (code.map(Code::Shared), Vec::new())
                     }
                     TypeDefKind::Future(ty) => {
-                        let code = if future_payloads.contains(ty) {
+                        let snake = ty
+                            .map(|ty| names.mangle_name(ty))
+                            .unwrap_or_else(|| "unit".into());
+
+                        let code = if future_payloads.contains(&snake) {
                             None
                         } else {
-                            future_payloads.insert(ty);
+                            future_payloads.insert(snake.clone());
 
-                            let snake = ty
-                                .map(|ty| names.mangle_name(ty))
-                                .unwrap_or_else(|| "unit".into());
                             let camel = ty
                                 .map(|ty| names.type_name(ty, &seen, None))
                                 .unwrap_or_else(|| "None".into());