wiggle: make wasmtime a mandatory dep, get rid of own Trap enum (#5137)

* wiggle: no longer need to guard wasmtime integration behind a feature

this existed so we could use wiggle in lucet, but lucet is long EOL

* replace wiggle::Trap with wiggle::wasmtime_crate::Trap

* wiggle tests: unwrap traps because we cant assert_eq on them

* wasi-common: emit a wasmtime::Trap instead of a wiggle::Trap

formally add a dependency on wasmtime here to make it obvious, though
we do now have a transitive one via wiggle no matter what (and therefore
can get rid of the default-features=false on the wiggle dep)

* wasi-nn: use wasmtime::Trap instead of wiggle::Trap

there's no way the implementation of this func is actually
a good idea, it will panic the host process on any error,
but I'll ask @mtr to fix that

* wiggle test-helpers examples: fixes

* wasi-common cant cross compile to wasm32-unknown-emscripten anymore

this was originally for the WASI polyfill for web targets. Those days
are way behind us now.

* wasmtime wont compile for armv7-unknown-linux-gnueabihf either

crates/wiggle/test-helpers/examples/tracing.rs

@@ -32,7 +32,10 @@ impl_errno!(types::Errno);
 /// When the `errors` mapping in witx is non-empty, we need to impl the
 /// types::UserErrorConversion trait that wiggle generates from that mapping.
 impl<'a> types::UserErrorConversion for WasiCtx<'a> {
-    fn errno_from_rich_error(&mut self, e: RichError) -> Result<types::Errno, wiggle::Trap> {
+    fn errno_from_rich_error(
+        &mut self,
+        e: RichError,
+    ) -> Result<types::Errno, wiggle::wasmtime_crate::Trap> {
         wiggle::tracing::debug!(
             rich_error = wiggle::tracing::field::debug(&e),
             "error conversion"
@@ -83,19 +86,19 @@ fn main() {
 
     // Exercise each of the branches in `foo`.
     // Start with the success case:
-    let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0, 0, 8);
+    let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0, 0, 8).unwrap();
     assert_eq!(
         r0,
-        Ok(types::Errno::Ok as i32),
+        types::Errno::Ok as i32,
         "Expected return value for strike=0"
     );
     assert!(ctx.log.borrow().is_empty(), "No error log for strike=0");
 
     // First error case:
-    let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1, 0, 8);
+    let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1, 0, 8).unwrap();
     assert_eq!(
         r1,
-        Ok(types::Errno::PicketLine as i32),
+        types::Errno::PicketLine as i32,
         "Expected return value for strike=1"
     );
     assert_eq!(
@@ -105,10 +108,10 @@ fn main() {
     );
 
     // Second error case:
-    let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2, 0, 8);
+    let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2, 0, 8).unwrap();
     assert_eq!(
         r2,
-        Ok(types::Errno::InvalidArg as i32),
+        types::Errno::InvalidArg as i32,
         "Expected return value for strike=2"
     );
     assert_eq!(