Reactor support. (#1565)

* Reactor support.

This implements the new WASI ABI described here:

https://github.com/WebAssembly/WASI/blob/master/design/application-abi.md

It adds APIs to `Instance` and `Linker` with support for running
WASI programs, and also simplifies the process of instantiating
WASI API modules.

This currently only includes Rust API support.

* Add comments and fix a typo in a comment.

* Fix a rustdoc warning.

* Tidy an unneeded `mut`.

* Factor out instance initialization with `NewInstance`.

This also separates instantiation from initialization in a manner
similar to https://github.com/bytecodealliance/lucet/pull/506.

* Update fuzzing oracles for the API changes.

* Remove `wasi_linker` and clarify that Commands/Reactors aren't connected to WASI.

* Move Command/Reactor semantics into the Linker.

* C API support.

* Fix fuzzer build.

* Update usage syntax from "::" to "=".

* Remove `NewInstance` and `start()`.

* Elaborate on Commands and Reactors and add a spec link.

* Add more comments.

* Fix wat syntax.

* Fix wat.

* Use the `Debug` formatter to format an anyhow::Error.

* Fix wat.

crates/test-programs/tests/wasm_tests/runtime.rs

@@ -1,8 +1,8 @@
-use anyhow::{bail, Context};
+use anyhow::Context;
 use std::fs::File;
 use std::path::Path;
 use wasi_common::VirtualDirEntry;
-use wasmtime::{Instance, Module, Store};
+use wasmtime::{Linker, Module, Store};
 
 #[derive(Clone, Copy, Debug)]
 pub enum PreopenType {
@@ -48,36 +48,19 @@ pub fn instantiate(
     let (reader, _writer) = os_pipe::pipe()?;
     builder.stdin(reader_to_file(reader));
     let snapshot1 = wasmtime_wasi::Wasi::new(&store, builder.build()?);
+
+    let mut linker = Linker::new(&store);
+
+    snapshot1.add_to_linker(&mut linker)?;
+
     let module = Module::new(&store, &data).context("failed to create wasm module")?;
-    let imports = module
-        .imports()
-        .map(|i| {
-            let field_name = i.name();
-            if let Some(export) = snapshot1.get_export(field_name) {
-                Ok(export.clone().into())
-            } else {
-                bail!(
-                    "import {} was not found in module {}",
-                    field_name,
-                    i.module()
-                )
-            }
-        })
-        .collect::<Result<Vec<_>, _>>()?;
 
-    let instance = Instance::new(&module, &imports).context(format!(
-        "error while instantiating Wasm module '{}'",
-        bin_name,
-    ))?;
-
-    instance
-        .get_export("_start")
-        .context("expected a _start export")?
-        .into_func()
-        .context("expected export to be a func")?
-        .call(&[])?;
-
-    Ok(())
+    linker
+        .module("", &module)
+        .and_then(|m| m.get_default(""))
+        .and_then(|f| f.get0::<()>())
+        .and_then(|f| f().map_err(Into::into))
+        .context(format!("error while testing Wasm module '{}'", bin_name,))
 }
 
 #[cfg(unix)]