Add some more allocators documentation
Initial work on adding an SVM classifier

It doesn't compile right now, but the approach is stubbed out
and actually part of the way there.
Invert the svm dependency

Since foreign-inference uses TemplateHaskell, we can't link in
svm-simple directly (because it uses C++ and the TH linker dies).
Inverting the dependency so that the caller of 'identifyErrorHandling'
code has to provide the classifier function.  The iiglue binary
can safely link against svm-simple, so it will provide a function
instead of just providing the classifier data blob.
The error handling analysis compiles again

There are still a few stubbed out functions.  Also, I need
to make a simpler interface for extracting training data.
Add a Binary instance for the classifier labels
Expose more training stuff.

This exposes the training label constructors.  It also adds a new
function to compute just feature vectors for a library.  This is
most useful for training.
Expose a little more SVM information

This lets this backend tweak gamma without having to bother the frontend
so much
Record success/failure blocks in the BasicFacts

This is the information used to compute feature vectors.
It is discovered while checking for known errors.
Add a type signature for generalize
Restructure the analysis phases for the error-reporting analysis

Before, each analysis was run over functions one at a time.  This
order was problematic because the known-error analysis relies on
information from the known-success analysis.  It would be useful to
have all of the known-success information available before looking for
failures.

This change applies each analysis in phases (over all functions).

This change also pushes the transitive error analysis to come after
the generalization pass has run so that it can collect as much
information as possible.
First draft of a feature vector

Normalize the collected features in a slightly arbitrary way
that seems kind of reasonable
Remove some commented-out code
More SVM commentary
Implement the new generalize function.

This is a very basic generalization procedure that relies
almost entirely on the results of the classifier.  It does
not do anything particularly smart itself.
Remove a bunch of obsoleted code
More explicit classifier selection

Use a separate ADT instead of just Maybe - this gives more flexibility
and lets us disable classification entirely.
Record error codes as they are encountered

These will be used in another generalization step
Add a new option to the error analysis

This is a flag to control generalization based on return values.
It is probably always a good idea to do it, but it will be
important to experiment with both settings.
Re-use a higher-order combinator, stub out an analysis step
Implement error code generalization