During the initial implementation of indexed inequalities, we added all possible indexable inequalities into the RAM with MakeIndexTransformer and then later when they weren't indexable we discharged the indexed inequalities from the RAM back into filters with IndexedInequalityTransformer. This approach is not very good and we can do much better.

The problem with this approach is that:

1. It massively overcomplicates the RAM because in between the MakeIndexTransformer and IndexedInequalityTransformer the program wasn't in an executable state.
2. If one wanted to disable the IndexedInequalityTransformer, then the program would crash (bad!).
3. It introduces extra passes into the compilation phase because of the extra complexity of adding and then removing inequalities to be indexed.
4. It's harder to maintain because the logic is overly complicated.
5. The solvers within IndexAnalysis can't be pure because it must retain the state of the discharged attributes for later querying.

In this PR I have eliminated the IndexedInequalityTransformer and instead ensured that inequalities which cannot be indexed are never indexed in the first place by simply not adding them in MakeIndexTransformer. I also cleaned up my section of the MakeIndexTransformer to be significantly more readable.

I also added a TODO where I tagged myself to ensure that if we do later want to support data structures with multiple attributes w/inequalities that we can quickly fix the code to support this.

In essence, the logic is simplified from before and nicely refactored and all contained within MakeIndexTransformer, allowing for subsequent PRs to make the IndexAnalysis solvers stateless.