peepmatic: Be generic over the operator type

This lets us avoid the cost of `cranelift_codegen::ir::Opcode` to
`peepmatic_runtime::Operator` conversion overhead, and paves the way for
allowing Peepmatic to support non-clif optimizations (e.g. vcode optimizations).

Rather than defining our own `peepmatic::Operator` type like we used to, now the
whole `peepmatic` crate is effectively generic over a `TOperator` type
parameter. For the Cranelift integration, we use `cranelift_codegen::ir::Opcode`
as the concrete type for our `TOperator` type parameter. For testing, we also
define a `TestOperator` type, so that we can test Peepmatic code without
building all of Cranelift, and we can keep them somewhat isolated from each
other.

The methods that `peepmatic::Operator` had are now translated into trait bounds
on the `TOperator` type. These traits need to be shared between all of
`peepmatic`, `peepmatic-runtime`, and `cranelift-codegen`'s Peepmatic
integration. Therefore, these new traits live in a new crate:
`peepmatic-traits`. This crate acts as a header file of sorts for shared
trait/type/macro definitions.

Additionally, the `peepmatic-runtime` crate no longer depends on the
`peepmatic-macro` procedural macro crate, which should lead to faster build
times for Cranelift when it is using pre-built peephole optimizers.

cranelift/peepmatic/crates/traits/src/lib.rs

@@ -0,0 +1,26 @@
+//! Shared traits, types, and macros for Peepmatic.
+//!
+//! This crate is used both at build time when constructing peephole optimizers
+//! (i.e. in the `peepmatic` crate), and at run time when using pre-built
+//! peephole optimizers (i.e. in the `peepmatic-runtime` crate and in
+//! Cranelift's Peepmatic integration at `cranelift/codegen/src/peepmatic.rs`).
+//!
+//! This crate is similar to a header file: it should generally only contain
+//! trait/type/macro definitions, not any code.
+
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+
+#[macro_use]
+mod operator;
+pub use operator::*;
+
+mod typing;
+pub use typing::*;
+
+/// Raise a panic about an unsupported operation.
+#[cold]
+#[inline(never)]
+pub fn unsupported(msg: &str) -> ! {
+    panic!("unsupported: {}", msg)
+}