Shuffle around the wiggle crates (#1414)

* Shuffle around the wiggle crates

This commit reorganizes the wiggle crates slightly by performing the
following transforms:

* The `crates/wiggle` crate, previously named `wiggle`, was moved to
  `crates/wiggle/crates/macro` and is renamed to `wiggle-macro`.

* The `crates/wiggle/crates/runtime` crate, previously named
  `wiggle-runtime`, was moved to `crates/wiggle` and is renamed to
  `wiggle`.

* The new `wiggle` crate depends on `wiggle-macro` and reexports the macro.

The goal here is that consumers only deal with the `wiggle` crate
itself. No more crates depend on `wiggle-runtime` and all dependencies
are entirely on just the `wiggle` crate.

* Remove the `crates/wiggle/crates` directory

Move everything into `crates/wiggle` directly, like `wasi-common`

* Add wiggle-macro to test-all script

* Fixup a test

crates/wiggle/generate/src/lifetimes.rs

@@ -0,0 +1,83 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub trait LifetimeExt {
+    fn is_transparent(&self) -> bool;
+    fn needs_lifetime(&self) -> bool;
+}
+
+impl LifetimeExt for witx::TypeRef {
+    fn is_transparent(&self) -> bool {
+        self.type_().is_transparent()
+    }
+    fn needs_lifetime(&self) -> bool {
+        self.type_().needs_lifetime()
+    }
+}
+
+impl LifetimeExt for witx::Type {
+    fn is_transparent(&self) -> bool {
+        match self {
+            witx::Type::Builtin(b) => b.is_transparent(),
+            witx::Type::Struct(s) => s.is_transparent(),
+            witx::Type::Enum { .. }
+            | witx::Type::Flags { .. }
+            | witx::Type::Int { .. }
+            | witx::Type::Handle { .. } => true,
+            witx::Type::Union { .. }
+            | witx::Type::Pointer { .. }
+            | witx::Type::ConstPointer { .. }
+            | witx::Type::Array { .. } => false,
+        }
+    }
+    fn needs_lifetime(&self) -> bool {
+        match self {
+            witx::Type::Builtin(b) => b.needs_lifetime(),
+            witx::Type::Struct(s) => s.needs_lifetime(),
+            witx::Type::Union(u) => u.needs_lifetime(),
+            witx::Type::Enum { .. }
+            | witx::Type::Flags { .. }
+            | witx::Type::Int { .. }
+            | witx::Type::Handle { .. } => false,
+            witx::Type::Pointer { .. }
+            | witx::Type::ConstPointer { .. }
+            | witx::Type::Array { .. } => true,
+        }
+    }
+}
+
+impl LifetimeExt for witx::BuiltinType {
+    fn is_transparent(&self) -> bool {
+        !self.needs_lifetime()
+    }
+    fn needs_lifetime(&self) -> bool {
+        match self {
+            witx::BuiltinType::String => true,
+            _ => false,
+        }
+    }
+}
+
+impl LifetimeExt for witx::StructDatatype {
+    fn is_transparent(&self) -> bool {
+        self.members.iter().all(|m| m.tref.is_transparent())
+    }
+    fn needs_lifetime(&self) -> bool {
+        self.members.iter().any(|m| m.tref.needs_lifetime())
+    }
+}
+
+impl LifetimeExt for witx::UnionDatatype {
+    fn is_transparent(&self) -> bool {
+        false
+    }
+    fn needs_lifetime(&self) -> bool {
+        self.variants
+            .iter()
+            .any(|m| m.tref.as_ref().map(|t| t.needs_lifetime()).unwrap_or(false))
+    }
+}
+
+pub fn anon_lifetime() -> TokenStream {
+    quote!('_)
+}