This adds thread safety to the refdb_fs by using the new
git_sortedcache object and also by relaxing the handling of some
filesystem errors where the fs may be changed out from under us.

This also adds some new threading tests that hammer on the refdb.

The refdb_fs implementation calls realloc directly on a reference
object when it wants to rename it.  It is not a public object, so
this doesn't mess with the immutability of references, but it does
assume certain constraints on the reference representation.  This
commit wraps that assumption in an isolated API to isolate it.

This adds two other APIs that I need to the sortedcache type.

This adds a convenient new data type for caching the contents of
file in memory when each item in that file corresponds to a name
and you need to both be able to lookup items by name and iterate
over them in some sorted order.  The new data type has locks in
place to manage usage in a threaded environment.

If there were symbolic refs among the loose refs then the code
to create packed-refs would fail trying to parse the OID out of
them (where Git just skips trying to pack them).  This fixes it.

Quiet down some warnings

Fix p_inet_pton on windows

p_inet_pton on Windows should set errno properly for callers.
Rewrite p_inet_pton to handle error cases correctly and add
test cases to exercise this function.

Use time(2) to get the time

We didn't use the added precision in gettimeofday, so remove it.
This prevents us from having an unnecessary reimplementation on
win32.

Don't expose git_hash_ctx since it's internal

And doing so makes the mingw build choke.

odb: move hashing to the frontend for streaming

odb: Straighten oid prefix handling

index: report when it's locked

When implementing the ssh testing, the move to the script made it so
the first test suite's exit code was ignored. Check whether the main
tests fail and exit with an error in that case.

Report the index being locked with its own error code in order to be
able to differentiate, as a locked index is typically the result of a
crashed process or concurrent access, both of which often require user
intervention to fix.

Bring Valgrind back!

If none of the backends support direct writes and we must stream the
whole file, we already know what the object's id should be; so use the
stream's functions directly, bypassing the frontend's hashing and
overwriting of our existing id.

Clarify the role of each function and in particular mention that there
is no need for the backend or stream to worry about the object's id,
as it will be given when `finalize_write` is called.

The frontend is in charge of calculating the id of the objects. Thus
the backends should treat it as a read-only value. The positioning in
the function signature made it seem as though it was an output
parameter.

Make the id const and move it from the front to behind the subject
(backend or stream).

push: handle tag chains correctly

Add "git init"-like example

This adds a new API for creating a signature that uses the
config to look up "user.name" and "user.email".

Give credit to PHP for the p_readlink function in posix_w32.c

When dealing with a chain of tags, we need to enqueue each of them
individually, which means we can't use `git_tag_peel` as that jumps
over the intermediate tags.

Do the peeling manually so we can look at each object and take the
appropriate action.

Hash the data as it's coming into the stream and tell the backend what
its name is when finalizing the write. This makes it consistent with
the way a plain git_odb_write() performs the write.

This is in preparation for moving the hashing to the frontend, which
requires us to handle the incoming data before passing it to the
backend's stream.

revparse: Free left side of invalid range revspecs