Now use mmap when comparing the files, and do so in parallel for up to four at a time.  Yet this doesn’t seem to be any faster than the previous method. :(
Ignore all *.xcbkptlist files.
New compare method using dispatch_io.

This dramatically improves performance for drives which can keep up
(i.e. SSDs).  On mine, the previous method maxed out at ~140 MB/s,
while this method approaches 400 MB/s (about the limit for my SSD).

It doesn't appear to have an impact (good or bad) on spindle disks or
other slower disks (e.g. SD cards).
Removed the last remaining dispatch_sync.
Flush stdout after significant headers, to ensure timely updates to the end user.
Abort if there's any issues enumerating the two files/folders.
Better error logging.
Use fewer queues, and share the concurrency limiter between both sides for the hashing.
Fail the hashing step if unable to complete the hash for any file.
Use slightly more interesting progress indicators.
Rejigged computeHashes() to be completely asynchronous.

This lets the computation start for both sides of the diff more or less
simultaneously and concurrently, including enumerating the file
hierarchy.

It also lets failures be propogated back in places where this wasn't
possible before (e.g. read errors during dispatch_io operations).

This also accidentally fixes the bug I introduced sometime yesterday
whereby file descriptors were never being released, and would run out.
Some kind of retain cycle on the dispatch_io_ts, I assume.
Increase the high-water mark to 16 MiB, to trade off increased memory use with better performance in I/O > CPU scenarios.
Use the default queue priority, rather than low, for responding to file reads.
Against all reason, this seems to make I/Os faster.

I'm really pretty sure that dispatch_io sets this flag anyway, under
the covers, so I'm suspicious that it appears to make any difference at
all.  But there is a difference.  Small, but measurable and
reproducible.
Added NOT_NULL attributes to the remaining functions.
Split the concurrency limiter for hashing back into two independent halves.

Unifying it had the unsurprising effect of creating occasional
bottlenecks on the slower disk, but moreso than I'd anticipated, such
that it outweighed any potential benefits.
Added clean version of the `cadiff` scheme.

I had accidentally added one that had a bunch of debug crap in it.  I
used git rewrite to purge that, which is why the "Shared the `cadiff`
scheme" commit from a while back appears to be missing some bits.  This
is the missing bits.
Merge branch 'master' of https://github.com/wadetregaskis/cadiff

Conflicts:
	.gitignore
	cadiff/main.m