Implement lowered-then-lifted functions (#4327)

* Implement lowered-then-lifted functions

This commit is a few features bundled into one, culminating in the
implementation of lowered-then-lifted functions for the component model.
It's probably not going to be used all that often but this is possible
within a valid component so Wasmtime needs to do something relatively
reasonable. The main things implemented in this commit are:

* Component instances are now assigned a `RuntimeComponentInstanceIndex`
  to differentiate each one. This will be used in the future to detect
  fusion (one instance lowering a function from another instance). For
  now it's used to allocate separate `VMComponentFlags` for each
  internal component instance.

* The `CoreExport<FuncIndex>` of lowered functions was changed to a
  `CoreDef` since technically a lowered function can use another lowered
  function as the callee. This ended up being not too difficult to plumb
  through as everything else was already in place.

* A need arose to compile host-to-wasm trampolines which weren't already
  present. Currently wasm in a component is always entered through a
  host-to-wasm trampoline but core wasm modules are the source of all
  the trampolines. In the case of a lowered-then-lifted function there
  may not actually be any core wasm modules, so component objects now
  contain necessary trampolines not otherwise provided by the core wasm
  objects. This feature required splitting a new function into the
  `Compiler` trait for creating a host-to-wasm trampoline. After doing
  this core wasm compilation was also updated to leverage this which
  further enabled compiling trampolines in parallel as opposed to the
  previous synchronous compilation.

* Review comments

crates/environ/src/component/info.rs

@@ -114,6 +114,10 @@ pub struct Component {
     /// when instantiating this component.
     pub num_runtime_instances: u32,
 
+    /// Same as `num_runtime_instances`, but for `RuntimeComponentInstanceIndex`
+    /// instead.
+    pub num_runtime_component_instances: u32,
+
     /// The number of runtime memories (maximum `RuntimeMemoryIndex`) needed to
     /// instantiate this component.
     ///
@@ -355,7 +359,7 @@ pub enum Export {
         /// The component function type of the function being created.
         ty: TypeFuncIndex,
         /// Which core WebAssembly export is being lifted.
-        func: CoreExport<FuncIndex>,
+        func: CoreDef,
         /// Any options, if present, associated with this lifting.
         options: CanonicalOptions,
     },
@@ -369,6 +373,9 @@ pub enum Export {
 /// Canonical ABI options associated with a lifted or lowered function.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CanonicalOptions {
+    /// The component instance that this bundle was associated with.
+    pub instance: RuntimeComponentInstanceIndex,
+
     /// The encoding used for strings.
     pub string_encoding: StringEncoding,
 
@@ -382,17 +389,6 @@ pub struct CanonicalOptions {
     pub post_return: Option<RuntimePostReturnIndex>,
 }
 
-impl Default for CanonicalOptions {
-    fn default() -> CanonicalOptions {
-        CanonicalOptions {
-            string_encoding: StringEncoding::Utf8,
-            memory: None,
-            realloc: None,
-            post_return: None,
-        }
-    }
-}
-
 /// Possible encodings of strings within the component model.
 //
 // Note that the `repr(u8)` is load-bearing here since this is used in an