Remove all checked in *.wasm files to the repo (#563)

* Tidy up the `hello` example for `wasmtime`

* Remove the `*.wat` and `*.wasm` files and instead just inline the
  `*.wat` into the example.

* Touch up comments so they're not just a repeat of the `println!`
  below.

* Move `*.wat` for `memory` example inline

No need to handle auxiliary files with the ability to parse it inline!

* Move `multi.wasm` inline into `multi.rs` example

* Move `*.wasm` for gcd example inline

* Move `*.wat` inline with `import_calling_export` test

* Remove checked in `lightbeam/test.wasm`

Instead move the `*.wat` into the source and parse it into wasm there.

* Run rustfmt

crates/api/examples/hello.rs

@@ -1,11 +1,8 @@
 //! Translation of hello example
 
-extern crate alloc;
-
-use alloc::rc::Rc;
 use anyhow::{ensure, format_err, Context as _, Result};
 use core::cell::Ref;
-use std::fs::read;
+use std::rc::Rc;
 use wasmtime_api::*;
 
 struct HelloCallback;
@@ -19,25 +16,37 @@ impl Callable for HelloCallback {
 }
 
 fn main() -> Result<()> {
-    // Initialize.
+    // Configure the initial compilation environment, creating more global
+    // structures such as an `Engine` and a `Store`.
     println!("Initializing...");
     let engine = HostRef::new(Engine::default());
     let store = HostRef::new(Store::new(&engine));
 
-    // Load binary.
+    // Next upload the `*.wasm` binary file, which in this case we're going to
+    // be parsing an inline text format into a binary.
     println!("Loading binary...");
-    let binary = read("examples/hello.wasm")?;
+    let binary = wat::parse_str(
+        r#"
+            (module
+              (func $hello (import "" "hello"))
+              (func (export "run") (call $hello))
+            )
+        "#,
+    )?;
 
-    // Compile.
+    // Compiler the `*.wasm` binary into an in-memory instance of a `Module`.
     println!("Compiling module...");
     let module = HostRef::new(Module::new(&store, &binary).context("> Error compiling module!")?);
 
-    // Create external print functions.
+    // Here we handle the imports of the module, which in this case is our
+    // `HelloCallback` type and its associated implementation of `Callback.
     println!("Creating callback...");
     let hello_type = FuncType::new(Box::new([]), Box::new([]));
     let hello_func = HostRef::new(Func::new(&store, hello_type, Rc::new(HelloCallback)));
 
-    // Instantiate.
+    // Once we've got that all set up we can then move to the instantiation
+    // phase, pairing together a compiled module as well as a set of imports.
+    // Note that this is where the wasm `start` function, if any, would run.
     println!("Instantiating module...");
     let imports = vec![hello_func.into()];
     let instance = HostRef::new(
@@ -45,24 +54,19 @@ fn main() -> Result<()> {
             .context("> Error instantiating module!")?,
     );
 
-    // Extract export.
+    // Next we poke around a bit to extract the `run` function from the module.
     println!("Extracting export...");
     let exports = Ref::map(instance.borrow(), |instance| instance.exports());
     ensure!(!exports.is_empty(), "> Error accessing exports!");
     let run_func = exports[0].func().context("> Error accessing exports!")?;
 
-    // Call.
+    // And last but not least we can call it!
     println!("Calling export...");
     run_func
         .borrow()
         .call(&[])
         .map_err(|e| format_err!("> Error calling function: {:?}", e))?;
 
-    // Shut down.
-    println!("Shutting down...");
-    drop(store);
-
-    // All done.
     println!("Done.");
     Ok(())
 }