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.