… grouped entity storage

This commit moves away from `derive!` for operation definitions, to the
new `#[operation]` macro, and implements a number of
changes/improvements to the `Operation` type and its related APIs.

In particular with this commit, the builder infrastructure for
operations was finalized and started to be tested with "real" ops.
Validation was further improved by typing operands with type constraints
that are validated when an op is verified. The handling of successors,
operands, and results was improved and unified around a shared
abstraction.

The pattern and pattern rewriter infrastructure was sketched out as
well, and I anticipate landing those next, along with tests for all of
it.

Once patterns are done, the next two items of note are the data analysis
framework, and the conversion framework. With those done, we're ready to
move to the new IR.

…ype-erased attribute values

…ication, rework visitors, and implement low-level pattern matchers

… ops

…rinting

This commit adds the following useful tools (used in later commits):

* The `Graph` trait for abstracting over flow graphs
* The `GraphVisitor` and `DfsVisitor` primitives for performing and
  hooking into depth-first traversals of a `Graph` in either pre-order
  or post-order, or both.
* Type aliases for pre- and post-order dfs visitors for blocks
* The `GraphDiff` trait and `CfgDiff` data structure for representing
  pending insertions/deletions in a flow graph. This enables incremental
  updating of flow graph dependent analyses such as the dominator tree.

This introduces the incrementally updateable dominator and
post-dominator analyses from LLVM, based on the Semi-NCA algorithm. This
enables us to keep the (post-)dominator tree analysis up to date during
rewriting of the IR, without needing to recompute it from scratch each
time.

This is an initial port of the original C++ code, modified to be more
Rust-like, while still remaining quite close to the original. This could
be easily cleaned up/rewritten in the future to be more idiomatic Rust,
but for now it should suffice.

This commit implements the generic loop analysis from LLVM, in Rust. It
is a more sophisticated analysis than the one in HIR1, and provides us
with some additional useful information that will come in handy during
certain transformations to MASM.

See the "Loop Terminlogy" document on llvm.org for details on how LLVM
reasons about loops, which corresponds to the analysis above.