Move most module initialization to compiled code (bytecodealliance#13487)

* Don't panic in `Slab::{get,get_mut}`

Instead return `None`. This helps prevent corruption of the GC heap from
causing panics.

* Don't allow memset with funcref arrays

Even `ref.null func` is intern'd, so nothing is candidate for memset on
a `funcref` array. Overall just ban memset on all reference-typed arrays
for now to optimize the easy case of scalar data, but leave optimizing
reference types for later.

* Move most module initialization to compiled code

This commit is a large refactoring of how modules are initialized in
Wasmtime. Notably all of the work done post-allocation, but pre-start,
is now done in compiled code instead. This means that global
initialization, active table segments, passive segment evaluation, etc,
now all happens in compiled code. The primary motivation for this is to
resolve some GC-related fuzz-bugs where initialization on the host is
taking an excessively long time. A secondary motivation is to apply fuel
metering and epoch yielding to these constructs in the same manner that
normal wasm code has these applied.

Much refactoring was needed in this commit to achieve this goal. Many
primitives were transitioned from runtime state to exclusively
compile-time state for example. Infrastructure was additionally added
for a new kind of `FuncKey` corresponding to this one-off-use startup
function. Overall though the net effect of this change is to mostly
delete code since so much of the runtime is now no longer necessary. An
example of this is that const-eval is now completely removed from the
runtime as the fully-general const-evaluation now happens exclusively
through compiled code.

Special care was needed here for the static table and memory
initialization that Wasmtime performs. For example there's a small dance
between compile-time and run-time where at compile-time we don't know if
static data segments should be applied, and it's only at run-time where
we know if CoW is in effect. Additionally care was taken throughout this
refactoring to avoid generating this new startup function unless it's
necessary. It's hypothesized that skipping this function is going to be
a worthwhile optimization, which means that one mode of startup is
configured as "only necessary if memories say `needs_init()`". This is a
bit tricky to document and it's a bit non-standard, but it should get
the job done (and existing tests exercise this already).

* Review comments

Author: alexcrichton

crates/core/src/slab.rs

@@ -390,15 +390,11 @@ impl<T> Slab<T> {
     ///
     /// Returns `None` if the value has since been deallocated.
     ///
-    /// If `id` comes from a different `Slab` instance, this method may panic,
-    /// return `None`, or return an arbitrary value.
+    /// If `id` comes from a different `Slab` instance, this method may return
+    /// `None`, or return an arbitrary value.
     #[inline]
     pub fn get(&self, id: Id) -> Option<&T> {
-        match self
-            .entries
-            .get(id.0.index())
-            .expect("id from different slab")
-        {
+        match self.entries.get(id.0.index())? {
             Entry::Occupied(x) => Some(x),
             Entry::Free { .. } => None,
         }
@@ -408,15 +404,11 @@ impl<T> Slab<T> {
     ///
     /// Returns `None` if the value has since been deallocated.
     ///
-    /// If `id` comes from a different `Slab` instance, this method may panic,
-    /// return `None`, or return an arbitrary value.
+    /// If `id` comes from a different `Slab` instance, this method may return
+    /// `None`, or return an arbitrary value.
     #[inline]
     pub fn get_mut(&mut self, id: Id) -> Option<&mut T> {
-        match self
-            .entries
-            .get_mut(id.0.index())
-            .expect("id from different slab")
-        {
+        match self.entries.get_mut(id.0.index())? {
             Entry::Occupied(x) => Some(x),
             Entry::Free { .. } => None,
         }