Even more rename detection fixes

Sigh.

So, rename detection has problems; it appears that the basic loop that I initially wrote got a few things wrong with the bookkeeping for which files were matched with which others. I've experimented with some tests that try random diffs in large repos coupled with rename detection and I was able to reproduce a number of problems. This PR fixes the problems I've found so far...

The big issue turned out to be that I had written rename detection as a forward mapping (i.e. for each file, look at what it might have been renamed/copied to), but it really needed to written as a backward mapping (i.e. for each file, look at what is might have been renamed/copied from). The backward mapping prevents dumb errors like reporting that file A had been renamed to both B and C. With a backward mapping, it's easy to say A was renamed to B and also copied to C.

There are a number of other smaller errors that needed to be fixed as well, like not keeping track of similarity scores consistently so an earlier calculation of A to B could be accidentally overwritten if A to C was a closer match. That was fixed by keeping an array of best matches along with the closest match score where previously I was just keeping the best match (and storing the score in the delta record itself).

Comprehensively, this PR does:

- [x] Add rename detection options to `examples/diff.c`
- [x] Add `--raw` output helper function and add to `examples/diff.c`
- [x] Fixes to `git_diff_find_similar` to track file matches and similarity scores more carefully
- [x] Drive rename detection as backwards map from "to" side of diff instead of a forwards map from "from" side
- [x] Update `git_diff_find_similar` so finding "rewrites" and breaking them into separated add/delete records can be controlled separately (because `git diff --raw` finds these "rewrites" but just marks them as `M083` or something like that - i.e. `M` with a dissimilarity score, instead of actually splitting them).
- [x] Fix sorting function for diff to be aware of different status and use the correct left-side/right-side name
- [x] Clarify some documentation for rename detection public APIs
- [x] Add an "exact match" option that looks for renames but only provided the OIDs match exactly (which is cheap and easy, relatively speaking)
- [x] Extend rename detection tests to exercise these complex cases better
- [x] More tests that are directly comparable to core git to make sure decisions / mappings are the same
 
I also added a new public API `git_oid_nfmt` which is like `git_oid_fmt` except that it takes an output buffer length and zeros the output buffer after the first `GIT_OID_HEXSZ` bytes. Using this API, I could reimplement several of the existing APIs, plus it was useful to me in writing the new `git_diff_print_raw` function.

That new `git_diff_print_raw` function is my new favorite debugging tool for diff code. There is a wrapper in `tests-clar/diff/diff_helpers.c` that lets you just write `print_diff_raw(stderr, diff);` to get a quick and meaningful snapshot of a diff (also invocable from inside the debugger as needed).