This started as a complex new test for checkout going through the
"typechanges" test repository, but that revealed numerous issues
with checkout, including:

* complete failure with submodules
* failure to create blobs with exec bits
* problems when replacing a tree with a blob because the tree
  "example/" sorts after the blob "example" so the delete was
  being processed after the single file blob was created

This fixes most of those problems and includes a number of other
minor changes that made it easier to do that, including improving
the TYPECHANGE support in diff/status, etc.

This is just some cleanup code, rearranging some of the checkout
code where TYPECHANGE support was added and adding some comments
to the diff header regarding the constants.

When I wrote the diff code, I based it on core git's diff output
which tends to split a type change into an add and a delete.  But
core git's status has the notion of a T (typechange) flag for a
file.  This introduces that into our status APIs and modifies the
diff code so it can be forced to not split type changes.

Diff submodule tests and fixes

* tests-clar/status: remove an unused variable
* clone: fix -Wmaybe-uninitialized warning

Deploy git_repository_set_head()

The adds a test for the submodule diff capabilities and then
fixes a few bugs with how the output is generated.  It improves
the accuracy of OIDs in the diff delta object and makes the
submodule output more closely mirror the OIDs that will be used
by core git.

There are a few cases where diff should leave directories in
the diff list if we want to match core git, such as when the
directory contains a .git dir.  That feature was lost when I
introduced some of the new submodule handling.

This restores that and then fixes a couple of related to diff
output that are triggered by having diffs with directories in
them.

Also, this adds a new flag that can be passed to diff if you
want diff output to actually include the file content of any
untracked files.

Diff: Show submodule diff

Fix a bug where ignorecase wasn't applied to ignores

The reference is only needed inside the function. We mistakenly
increased the reference counter causing the ODB not to get freed and
leaking descriptors.

Storing flushes in the refs vector doesn't let us recognize when the
remote is empty, as we'd always introduce at least one element into
it. These flushes aren't necessary, so we can simply ignore them.

We don't have anything useful that we could do with that oid anyway (We
need to query the submodule for the HEAD commit instead).

Without this, the following code creates the error "Failed to read
descriptor: Is a directory" when run against the submod2 test-case:

    const char* oidstr = "873585b94bdeabccea991ea5e3ec1a277895b698";
    git_tree* tree = resolve_commit_oid_to_tree(g_repo, oidstr);
    git_diff_list* diff = NULL;
    cl_assert(tree);
    cl_git_pass(git_diff_workdir_to_tree(g_repo, NULL, tree, &diff));

1. teach diff.c:maybe_modified to query git_submodule_status for the
   modification state of a submodule. According to the
   git_submodule_status docs, it will filter for to-ignore states
   already.

2. teach diff_output.c:get_workdir_content to check the submodule status
   again and create a line like:

      Subproject commit <SHA-1>\n
   or
      Subproject comimt <SHA-1>-dirty\n

   like git.git does.

diff_output.c:get_blob_content used to try to read the submodule commit
as a blob in the superproject's odb. Of course it cannot find it and
errors out with GIT_ENOTFOUND, implcitly terminating the whole diff
output.

This patch teaches it to create a text that describes the submodule
instead. The text looks like:

	Subproject commit <SHA1>\n

which is what git.git does, too.

ODB: re-load packfiles on failed lookup

Support for the core.ignorecase flag

Win64 cleanups