The previous README was just a quick usage note for others when I needed
to ask a question on IRC.

This avoids cloning names of repos that are processed successfully.

We know this runs on multiple threads now, so this debug line can be
removed.

I artificially limited the number of repositories processed to two for
testing so that I wouldn't download an mirror all of my repositories
while testing the program. Now that things seem to be working, remove
this artificial limit.

Rejigger some types and signatures to allow us to get references to the
`base_cgitrc` path instead of copying it for each repository.

Remove the `Iterator` test implementations that didn't work out.

Prefix each error line with the text "error: " to make it clear that's
what it is, and that it's separate from errors printed on other lines.

Worked out how to set up an `Iterator` for `MultiError` based on a
comment by 'chris-morgan' (https://old.reddit.com/user/chris-morgan) on
Reddit /r/rust:

> 1. Implement your own iterator type which wraps existing iterator
>    types (std::slice::Iter, and std::vec::IntoIter if you want a
>    consuming iterator).
>    Advantages: most flexible, ensures API stability if you
>    need to change internal details.
>    Disadvantages: a lot more effort, if you want to do it properly
>    (which involves implementing about ten traits on your iterator
>    wrapper type); and if slices or their iterators add something new,
>    you don’t get it unless you implement a wrapper yourself.
>
> 2. Have your iter() functions and IntoIterator implementations use the
>    standard iterator types directly.
>    Advantages: easier, gets you all the other trait implementations on
>    std::slice::Iter for free—AsRef, Clone, FusedIterator,
>    ExactSizeIterator, Debug, Send, DoubleEndedIterator, TrustedLen,
>    Sync).
>    Disadvantages: if you need to restructure things so that this is no
>    longer an option (e.g. store things in a different type of vector
>    and thus need to map it before presenting it to the user) it’s a
>    breaking change.
>
> 3. Implement Deref<Target = [(K, V)]> and just treat your Bucket<K, V>
>    as a &[(K, V)]. (Read-only; implement DerefMut if you want to allow
>    mutations of values.)
>    Advantages: easy, and lets you simply treat the whole thing as a
>    slice (this is what Vec<T> does).
>    Disadvantages: there really aren’t any, if it matches your purpose.
>    (If not, it’s useless.)

(https://old.reddit.com/r/rust/comments/7a0slp/questionimplementing_iterator_for_a_struct_with_a/)