Initial skeleton of some component model processing (#4005)

* Initial skeleton of some component model processing

This commit is the first of what will likely be many to implement the
component model proposal in Wasmtime. This will be structured as a
series of incremental commits, most of which haven't been written yet.
My hope is to make this incremental and over time to make this easier to
review and easier to test each step in isolation.

Here much of the skeleton of how components are going to work in
Wasmtime is sketched out. This is not a complete implementation of the
component model so it's not all that useful yet, but some things you can
do are:

* Process the type section into a representation amenable for working
  with in Wasmtime.
* Process the module section and register core wasm modules.
* Process the instance section for core wasm modules.
* Process core wasm module imports.
* Process core wasm instance aliasing.
* Ability to compile a component with core wasm embedded.
* Ability to instantiate a component with no imports.
* Ability to get functions from this component.

This is already starting to diverge from the previous module linking
representation where a `Component` will try to avoid unnecessary
metadata about the component and instead internally only have the bare
minimum necessary to instantiate the module. My hope is we can avoid
constructing most of the index spaces during instantiation only for it
to all ge thrown away. Additionally I'm predicting that we'll need to
see through processing where possible to know how to generate adapters
and where they are fused.

At this time you can't actually call a component's functions, and that's
the next PR that I would like to make.

* Add tests for the component model support

This commit uses the recently updated wasm-tools crates to add tests for
the component model added in the previous commit. This involved updating
the `wasmtime-wast` crate for component-model changes. Currently the
component support there is quite primitive, but enough to at least
instantiate components and verify the internals of Wasmtime are all
working correctly. Additionally some simple tests for the embedding API
have also been added.

crates/environ/src/component.rs

@@ -0,0 +1,34 @@
+//! Support for the component model in Wasmtime.
+//!
+//! This module contains all of the internal type definitions used by Wasmtime
+//! to process the component model. Despite everything being `pub` here this is
+//! not the public interface of Wasmtime to the component model. Instead this is
+//! the internal support to mirror the core wasm support that Wasmtime already
+//! implements.
+//!
+//! Some main items contained within here are:
+//!
+//! * Type hierarchy information for the component model
+//! * Translation of a component into Wasmtime's representation
+//! * Type information about a component used at runtime
+//!
+//! This module also contains a lot of Serialize/Deserialize types which are
+//! encoded in the final compiled image for a component.
+//!
+//! Note that this entire module is gated behind the `component-model` Cargo
+//! feature.
+//!
+//! ## Warning: In-progress
+//!
+//! As-of the time of this writing this module is incomplete and under
+//! development. It will be added to incrementally over time as more features
+//! are implemented. Current design decisions are also susceptible to change at
+//! any time. Some comments may reflect historical rather than current state as
+//! well (sorry).
+
+mod info;
+mod translate;
+mod types;
+pub use self::info::*;
+pub use self::translate::*;
+pub use self::types::*;