util: git__memzero() tweaks

On Linux: fix a warning message related to the volatile qualifier (cast)
On Windows: use SecureZeroMemory()

On both, inline the call, so that no entry point can lead back to this "secure" memory zeroing.
cred: deploy git__memzero to clear memory holding a password
Merge pull request #1654 from yorah/memzero

Memzero stuffs
ref: free the last ref when cancelling git_branch_foreach()

Also fixed an assert typo on nulltoken's HEAD
Merge pull request #1655 from yorah/fix/ref-memleak

ref: free the last ref when cancelling git_branch_foreach()
branch: More obvious semantics in `foreach`
status access by index, providing more details to callers
handle renames in status computation
git__strcasesort_cmp: strcasecmp sorting rules but requires strict equality
Fix some warnings
Clarify some docs and minor reordering

This simplifies some documentation and hopefully makes a couple
of things easier to read.  Also, this rearrages the order in this
branch so that the overall diff against the trunk will hopefully
be a bit cleaner.
Fix broken status EXCLUDE_SUBMODULES logic

The exclude submodules flag was not doing the right thing, in
that a file with no diff between the head and the index and just
a delete in the workdir could be excluded if submodules were
excluded.
Be more careful about the path with diffs

This makes diff more careful about picking the canonical path
when generating a delta so that it won't accidentally pick up a
case-mismatched path on a case-insensitive file system.  This
should make sure we use the "most accurate" case correct version
of the path (i.e. from the tree if possible, or the index if
need be).
Improve case handling in git_diff__paired_foreach

This commit reinstates some changes to git_diff__paired_foreach
that were discarded during the rebase (because the diff_output.c
file had gone away), and also adjusts the case insensitively
logic slightly to hopefully deal with either mismatched icase
diffs and other case insensitivity scenarios.
some simple case-sensitive index tests
Make index_insert keep existing case

In a case insensitive index, if you attempt to add a file from
disk with a different case pattern, the old case pattern in the
index should be preserved.

This fixes that (and a couple of minor warnings).
Always do tree to index diffs case sensitively

Trees are always case sensitive.  The index is always case
preserving and will be case sensitive when it is turned into a
tree.  Therefore the tree and the index can and should always
be compared to one another case sensitively.

This will restore the index to case insensitive order after the
diff has been generated.

Consider this a short-term fix.  The long term fix is to have the
index always stored both case sensitively and case insensitively
(at least on platforms that sometimes require case insensitivity).
Test has to work on case sensitive systems
More tests and bug fixes for status with rename

This changes the behavior of the status RENAMED flags so that they
will be combined with the MODIFIED flags if appropriate.  If a file
is modified in the index and also renamed, then the status code
will have both the GIT_STATUS_INDEX_MODIFIED and INDEX_RENAMED bits
set.  If it is renamed but the OID has not changed, then just the
GIT_STATUS_INDEX_RENAMED bit will be set.  Similarly, the flags
GIT_STATUS_WT_MODIFIED and GIT_STATUS_WT_RENAMED can both be set
independently of one another.

This fixes a serious bug where the check for unmodified files that
was done at data load time could end up erasing the RENAMED state
of a file that was renamed with no changes.

Lastly, this contains a bunch of new tests for status with renames,
including tests where the only rename changes are case changes.
The expected results of these tests have to vary by whether the
platform uses a case sensitive filesystem or not, so the expected
data covers those platform differences separately.
Add test of rename with no changes

A tree to index rename with no changes was getting erased by
the iteration routine (if the routine actually loaded the data
for the unmodified file).  This invokes the code path that was
previously messing up the diff and iterates twice to make sure
that the iteration process itself doesn't modify the data.