The performance was still not satisfying, even with faster recomputing
of successors. Doing it multiple times (Building the graph in each
breaker and sort passes) eats time. Caching in memory blows the
memory. Chosen solution: Cache this information in the database.

Created a new pass 'CsetDeps' which is run between 'InitCsets' and
'BreakRevCsetCycles' (i.e. changeset creation and first breaker pass).
It computes the changeset dependencies from the file-level
dependencies once and saves the result in the state, in the new table
'cssuccessor'. Now the breaker and sort passes can get the information
quickly, with virtually no effort. The dependencies are recomputed
incrementally when a changeset is split by one of the breaker passes,
for its fragments and its predecessors.

The loop check is now trivial, and integrated into the successor
computation, with the heavy lifting for the detailed analysis and
reporting moved down into the type-dependent SQL queries. The relevant
new method is 'loops'. Now that the loop check is incremental the pass
based checks have been removed from the integrity module, and the
option '--loopcheck' has been eliminated. For paranoia the graph setup
and modification code got its loop check reinstated as an assert,
redusing the changeset report code.

Renumbered the breaker and sort passes. A number of places, like graph
setup and traversal, loading of changesets, etc. got feedback
indicators to show their progress.

The selection of revision and symbol changesets for the associated
breaker passes was a bit on the slow side. We now keep changeset lists
sorted by type (during loading or general construction) and access
them directly.