* Initial implementation of resource types

This commit is an initial implementation of resource types for the
component model. The support added in this commit encompasses:

* `wasmparser` - parsing and validation of resource types
* `wasmprinter` - converting binary to text for resource types
* `wast` - parsing the text format for resource types
* `wasm-encoder` - writing the binary format for resource types

Other crates such as `wit-component` and `wasm-compose` saw a few small
changes to continue compiling but do not have support added for resource
types. WIT, for example, continues to not support resource types. That's
planned to be added in a subsequent commit. This support is intended to
be everything necessary for Wasmtime to start working on implementing
resource types, and once that's ready I'll circle back to implement WIT
support with host/guest/etc generators.

This is a substantial commit. The binary format for resources is pretty
minor but the major feature it requires support for is the type-checking
in validation. Resources effectively add an ML-module-style type system
to the component model with abstract types. This required quite a lot of
meticulous and careful plumbing throughout the validator along with a
rewritten form of checking subtypes.

This commit in theory implements what should be all or at least a large
bulk of what's specified for resources at the binary format layer.
Without spec tests for formal spec wording it can't really be said how
close to the current documentation it follows, but the intention was to
follow it closely. Tests have been attempted to be added here in a
number of interesting flavors but this implementation is highly likely
to still have holes and/or bugs that break the guarantees of resources.

Co-authored-by: Trevor Elliott <telliott@fastly.com>

* Implement validating outer aliases for types

* Add suggested tests

Co-authored-by: Trevor Elliott <telliott@fastly.com>

* Implement validation of imported/exported type names

This commit implements a long-desired feature for wasmparser's
implementation of the component model, which is to validate that all
referred-to-types in imports and exports are all themselves named via
imports or exports. This design took a surprising amount of
back-and-forth to settle on something which felt reasonable enough to
land, but the general idea landed on in this commit is relatively
simple:

* The validator's component state now maintains a set of
  exported/imported types.
* When exporting/importing an item, all referred-to types must be
  present in these sets.
* When exporting/importing a type, it's added to these sets.
* When exporting/importing an instance, that recursively is reached into
  to additionally add to these sets.

A minor optimization is that when validating that all names are in the
appropriate set it only has to travel one layer deep in the type
hierarchy since if the one-layer-deep version is "in the set" then it's
already previously validated that everything else is in the set.

The validation predicate here is done with sets and type traversal so
it's probably no the fastest thing in the world, but after all the
back-and-forth about how to implement this I think this is a reasonable
place to start and continue to iterate on the future as necessary.

It's important to note that while this does not alter the binary format
this does change the validation algorithm meaning previously valid
components may no longer be valid. For example the old output of
`wit-component` is no longer considered valid for exported instances.
Instead the output has been updated here to ensure the generated
components conform to the new shape expected by wasmparser.

The other affected crates in this commit are:

* `wit-component` - construction of exported instances is updated so the
  imports in to the shim-component generated are no longer aliased from
  the outer context but redefined in the shim's context. This bloats
  components a bit but the type information additionally shouldn't be
  that intensive.

* `wasm-smith` - the test for generated components has been disabled.
  This would need an update to filter what can be used in exports, but
  for now `wasm-smith` has fallen far enough behind the current state of
  components it seemed more prudent to simply disable it and get back to
  it later.

* Initial implementation of kebab names for resources

This commit is an initial pass at implementing methods, constructors,
and static methods on resource types. These introduce names of the
form:

* `[method]foo.bar`
* `[constructor]foo`
* `[static]foo.baz`

which all have their own set of validation rules about when the names
can be mentioned and when they can be applied. The current iteration of
validation and design is working through some upstream questions at this
time but otherwise the implementation here was relatively
straightforward and largely changing some base types and then
propagating the change outwards.

* Fix tests

* Test some kebab-case behavior

* Don't validate name export restrictions on instances

Instead only validate them on components and component types. Helps
handle an extra case that needs to work for WIT.

* Remove outer aliases from `wit-component`

This commit removes the last remaining usages of the `outer alias`
construct with components generated by `wit-component`. These aliases
ran afoul of the new check about exported type names since they
introduced unnamed types to the current context. Instead necessary types
are imported into the component under various names (the specific names
don't matter) and then the type information is reconstructed in the
component.

This additionally revealed a hole in the implementation of name
validation, as exhibited by the new test, where types provided as
imports needed to be substituted in the final instance type of an
instantiation. Previously only resource types were substituted, but now
type imports are additionally substituted to ensure that the final
output type doesn't refer to internal imported types which won't ever be
exported from any other context.

* Fix function/type import name conflict

Give them different prefixes to avoid clashes.

* Fix topological order of `LiveTypes`

This was improperly generating a topological ordering by adding items to
the order first. Instead the item needs to be added afterwards and
short-circuiting can still happen at the beginning but it's no longer
inserted there.

* Fix typos

* Update some tests with review comments

* Validate imported/exported entity types as well

* Update crates/wasmparser/src/validator/types.rs

Co-authored-by: Trevor Elliott <awesomelyawesome@gmail.com>

* Rename universals/existentials

Instead refer to them as "imported" and "defined" resources

* Move some resource handling out of `check_type_ref`

This logic feels better within `add_entity` to me at least

* Fix freshening resource types when instances are exported

When an instance type is used to declare an export any resources
mentioned internally must be freshened to become unique to ensure that
other uses of the same instance type don't conflict with the original use.

* Assert defined/imported resources are always unique

Insertion into this map should never overlap with previous insertions
and would have uncovered the bug fixed in the prior commit, so add
runtime-level assertions that these maps are only appended to.

* Add issues for TODOs

---------

Co-authored-by: Trevor Elliott <telliott@fastly.com>
Co-authored-by: Trevor Elliott <awesomelyawesome@gmail.com>