Rename iteB, andB, notB, as iteF, andF, and notF.

In preparation for renaming Bool BoolF.
Remove concrete constructor optimization from implementation.

This is in preparation for making a correct implementation.

Some notes:
* The generated code is simpler now
* We see about a 5x performance degredation on shampi (which was dominated by
  concrete evaluation)
* There are some bugs with over-eagerness which I haven't fixed yet.
Disable only those tests which are failing.
Remove some dead code.
Remove all "explicit" errors.

They were mostly a hack to get around the fact that we don't handle errors
properly. Now that we plan to handle errors properly, we shouldn't need
explicit errors anymore.

The code is much nicer without them.
Some more test cases fail, because we don't yet properly handle implicit
errors.
Removed all optimizations and IO from Symbolic implementation.

The code is way nicer.

A couple more tests are failing now, not sure why.
shampi's at 60s now (4-5x slower than we want it to be).
Rough draft of code for select and partial boolean operations.

The very basic tests I ran appear to work as desired.
Pulled BoolFF into separate FiniteFormula module.
Split Formula and FiniteFormula into different modules.

Started adding integer support, but it's not there yet.
Simplify boolean formulas greatly by removing premature optimizations.
Clean up BoolF by specializing andF and orF.

Which is easy, now that we have selectF and not so many special cases.
Gets rid of wait2F and partial2F.
Making a snapshot, because I don't understand the current state.
Pull stableNameEq out of Types into its own module.

Because it is really in no way specific or related to Types.
Pulled Model out of Types into its on module.
Renamed Smten.Runtime.Types to Smten.Runtime.Formula

To reflect that that's really what the module contains: the structure of an
SMT formula.
Temporally remove support for symbolic integer and bit.

In preparation for properly supporting fairness in SMT formulas. Baby steps.
Switched to new representation for boolean formula.

This is a very big change. Including:
* Store concrete values in Model, not symbolic
* Support incremental queries properly in Symbolic0
* Avoid name clashes between concrete and symbolic Bool, Integer, Bit,
  where possible
Core error tests pass.
Fixed bug in realize for BoolF.

It wasn't reducing to the canonical representation of trueF or falseF it ought
to have, so concrete evaluation appeared to be symbolic.

Also:
* Change Select to wait as long as needed to remove non-determinacy
* Don't provide dummy list monad implementation for Symbolic monad
* All the core test cases (not involving symbolic integers) now appear to work.
Simplify the implementation of select.

Given the assumption we will wait for something to happen to both arguments
regardless, we no longer need concurrency.