Tentative rewrite of some access path functionality

The access paths are more brief and more abstract now.  More
significantly, they also tag each path component with its *type*.
This has to be performed at concrete access path construction time
because the types depend on the bitcasts present, which can't be
reconstructed based on types alone (i.e., based on an
AbstractAccessPath).
Restore the original structure of access paths

This re-introduces all of the AccessDeref components for accuracy.
Add an accessor to retain compatibility with untagged access path components

Now all components are tagged with a type.  Code not expecting this
needed to be modified - this change introduces a backwards-compatible
accessor that strips the types.
Add an 'AccessUnion' component to AccessPaths

This is required to distinguish union fields from struct fields (since
unions in LLVM do not carry information about their fields).  The
discriminator is the Type that is used as a tag with AccessUnion - it
tells the type of the union field being accessed.

This change also, unfortunately, changes the AccessPath constructed
for some values: namely those whose base value was formerly a bitcast.
Now, the base value does not have the bitcast.  This is a byproduct of
the new matching required to recognize unions, but it should have
minimal impact on client code.  If looking up access paths by their
base value, just be sure to strip bitcasts from your key before
performing the lookup.
Add more generic union handling

This more general version handles unions that are not necessarily
embedded within a struct.
Expose the AccessPathError constructors

These are useful for matching and re-throwing access-path
related errors.
Track the baseType of an AccessPath separately from its baseValue

This is a minor tweak, but it allows us to more easily work with paths
that begin with a value that is bitcast to another type.  Before,
paths would look like they started at the type pre-bitcast.  Now the
recorded base value will be the same but the recorded base type is the
type cast *to*.

This may seem odd, but if the value is explicitly cast *to* something
else, that is much more likely to be its true type.

It may be prudent to split this into a different function so that both
behaviors are available if required.
More accurate type tags for access path components

Use the baseType instead of the type of the baseValue in AccessPath
now, since they can be different and baseType is more accurate.
WIP rewrite of the CFG/Dataflow analysis
Interim checkin, possibly working.
Add a unique exit node
Implement the CFG and dataflow analysis together, but export separate cleaner modules

This lets them see everything they need but lets us hide all of the
implementation details from the user.  The details are still available
from LLVM.Analysis.CFG.Internal, with the usual caveat that the interface
there is unstable.

Hopefully the public APIs will see much less churn...
Add a new function for retrieving dataflow analysis results

This adds a special helper, dataflowResult, to get the result at the
combined exit node.  The old function was renamed dataflowResultAt, to
get the result at a particular instruction.

This makes the common case easier and other cases possible.
If a fact is missing in a dataflow result, return top

Facts will not be available for unreachable code, so return
top in those cases.
New tests for the NoReturns analysis
A much improved NoReturns analysis using the new dataflow framework
Build a bit more as we improve the dataflow framework
Haddock fixes, clean up warnings

Also remove some spurious Show constraints from debugging
Remove some stray doc comments
Make DataflowAnalysis a data type instead of a typeclass

This requires far fewer type system extensions (especially for users).
No longer requires FlexibleInstances, MultiParamTypeClasses,
FlexibleContexts, or TypeSynonymInstances.

This also simplifies a few contexts.  Dataflow facts must still be
instances of BoundedMeetSemiLattice, but that is Haskell98.