First steps towards a better in-sync checking system that does not rely
on a merge-conflict-prone explicit hash digest.

This mostly supplants the hash comparison-based checking, though it's
still in rough form.

This is the first step towards being able to a more expansive type - one
that carries the pruning and digest information - directly within the
existing Lock interface.

This is a start at isolating verification logic into a discrete package.
Not sure how far we'll be able to make this go without creating some
import loops.

THis includes changes across both dep and gps towards transparently
working with vendor trees that are both configurably pruned and
verifiable.

We're now relying entirely on real validation - no more hash digest
comparisons and meaningless conflicts!

Both of these subsystems make more sense in the verification package
than in gps itself.

This encompasses the first pass at the new, more abstracted diffing
system, and the DeltaWriter implementation on top of it. Tests are
needed, but cursory testing indicates that we successfully capture all
types of diffs and regenerate only the subset of projects that actually
need to be touched.

Also convert the SafeWriter to use LockDelta.

Add output to all of the information we assemble when checking if the
Lock satisfies the current input set.

Also some refactoring of the ctx.LoadProject() process to have fewer
partial states.

Tests are now almost completely working, after updating all the outputs
to the new lock format. There is also an assortment of other fixes in
here, mostly related to fixing nil pointer panics, that were uncovered
by fixing up these tests.

There was no real need to delineate between Lock and LockWithImports.
The old Lock had the InputsDigest concept, which was even less feasible
for theoretical implementations of Lock to have, so this can't possibly
be more harmful.

Also a bunch of docs for the verify package.

This just abstracts and reuses the feedback already utilized by
DeltaWriter.Write().

Also better prepare it for public consumption by exporting its members,
renaming some methods and improving docs.

These should be nearly comprehensive tests for lock diffing behaviors.
They follow the same functional transform table testing pattern as with
the lock satisfaction tests.

Some tests were complaining of a data race when writing to ctx.Out on a
vendor verification failure. It's not clear why those tests were
failing, but the complaint became a forcing function to refactor the
previously-sloppy use of a channel and os.Exit(1) within a goroutine to
encapsulation in a method on dep.Project.