[WIP-DO NOT REVIEW] Equivalence tracking in Fusion

[jacobhinkle]

There are multiple stages in which we use the notion of equivalence of Vals. For example, both scheduling and lowering use root domain maps which map rfactor IterDomains of producers to root IterDomains of consumers. Later in lowering (but increasingly in other stages as well see #320), simplifyExpr does term rewriting which is based on exploring spaces of equivalent expression trees and doing replacement based on complexity heuristics.

Meanwhile, we also need to prove things, such as whether a predicate is always true unconditionally. This is also increasingly common since the introduction of dynamic fusions. For example, as mentioned in #380 it is difficult currently to check that the expanded extent of a concretized IterDomain is equal to 1, since we must do so without using an ExpressionEvaluator in that case.

In order to increase the power of our simplification and equivalence checking ability, this PR makes the following key changes:

1. In addition to .name() which numbers each val by its ValType, each Val now has a .number() which is independent of val type, and Fusion can look up any Val* from its number.
2. The UnionFind class is introduced which is a very efficient class for tracking equivalence classes. https://en.wikipedia.org/wiki/Disjoint-set_data_structure. This is similar to DisjointSets and may some day be a valid replacement for it, but the focus of UnionFind is on quick merging and pairwise comparison, with slower extraction of entire equivalence classes.
3. The ValEquivalence class is introduced which plumbs the .number() of each val into a UnionFind and implements some methods for simplification/selection of Vals. An object of this class can quickly attest or test equivalence of any two Vals even if they are of different types, such as Int and NamedScalar. This forms the basis of a term rewriting system. The Fusion holds a single ValEquivalence object representing the weakest form of equivalence (TODO).
4. The ExprEquivalence class is introduced which is based on ValEquivalence. It allows us to propose "sketches" of new Exprs and check whether an Expr whose inputs and attributes are all equivalent already exists. This will be useful functionality for implementing simplification/optimization via equality saturation as it helps to limit the number of created Vals and Exprs when exploring rewrites. This could be useful for simplifyExpr, for passes like reduce-broadcast fusions in lowering, or for other graph optimization passes such as in Cast opt pass #355.
5. Adds the ability to test or attest equivalences of Vals at any point. NOT YET STARTED
6. Organizes integer constants such that int constant expressions have a single representative, so that individual pairwise attestations propagate properly. This makes it trivial to check int equality proofs at any point in the program (TODO). Note that inequalities are more difficult to handle, but that quick equality checking might aid in proving inequalities in some cases.

All of these are currently an early work in progress.