Remote deletion

When we delete a remote, we also need to go through its fetch refspecs
and remove the references they create locally.

pack: init the cache on packfile alloc

Better global search path sandboxing in tests

When running multithreaded, it is not enough to check for the offmap
allocation. Move the call to cache_init() to packfile allocation so we
can be sure it is always allocated free of races.

This fixes #2355.

There are a number of tests that modify the global or system
search paths during the tests.  This adds a helper function to
make it easier to restore those paths and makes sure that they
are getting restored in a manner that preserves test isolation.

Initialize local variable

Increase config snapshot usage

Add R bindings to the README

And decrease extra reload checks of config data.

Improve checks for ignore containment

Make pack object lookup use loops

Minor fix for previously merged netops code.

The code doesn't use SSL and a test requires it.

The base object is a good cache candidate, so we shouldn't forget to add
it to the cache.

This avoid allocating the array on the heap for relatively small
chains. The expected performance increase is sadly not really
noticeable.

Instead of going through a special entry in the chain, let's pass it as
an output parameter.

Pass unconverted Unicode path data when iconv doesn't like it

Be more careful with user-supplied buffers

Some improvements to the cert checking

Configuration snapshotting

The switch makes the loop somewhat unwieldy. Let's assume it's fine and
perform the check when we're accessing the data.

This makes our code look a lot more like git's.

Dependency chains are often large and require a few
reallocations. Allocate a 64-element chain before doing anything else to
avoid allocations during the loop.

This value comes from the stack-allocated one git uses. We still
allocate this on the heap, but it does help performance a little bit.

Bring back the use of the delta base cache for unpacking objects. When
generating the delta chain, we stop when we find a delta base in the
pack's cache and use that as the starting point.

We currently make use of recursive function calls to unpack an object,
resolving the deltas as we come back down the chain. This means that we
have unbounded stack growth as we look up objects in a pack.

This is now done in two steps: first we figure out what the dependency
chain is by looking up the delta bases until we reach a non-delta
object, pushing the information we need onto a stack and then we pop
from that stack and apply the deltas until there are no more left.

This version of the code does not make use of the delta base cache so it
is slower than what's in the mainline. A later commit will reintroduce
it.

Repeating this error message makes it harder to find out where we
actually are finding the error, and they don't really describe what
we're trying to do.

Add filter options and ALLOW_UNSAFE

It seems that with the various recent changes to reference updating
and reflog writing, that the thread safety of refdb updates has
been reduced (either that or it was never thread safe and the
window for error has increased).  Either way, this test is now
sometimes segfaulting which is no good, so let's disable the test
for now.  We don't really make any public promises about thread
safety for this type of operation, so I think this is acceptable,
at least in the short term.

Only on a filesystem that is composed/decomposed insensitive,
should be testing that a branch can be looked up by the opposite
form and still work correctly.

One of the test helpers provides a quick way for looking up a
boolean key.  But if the key way missing completely, the check
would actually raise an error.  Given the way we use this helper,
if the key is missing, this should just return false, I think.