Improve checks for ignore containment

The diff code was using an "ignored_prefix" directory to track if
a parent directory was ignored that contained untracked files
alongside tracked files. Unfortunately, when negative ignore rules
were used for directories inside ignored parents, the wrong rules
were applied to untracked files inside the negatively ignored
child directories.

This commit moves the logic for ignore containment into the workdir
iterator (which is a better place for it), so the ignored-ness of
a directory is contained in the frame stack during traversal.  This
allows a child directory to override with a negative ignore and yet
still restore the ignored state of the parent when we traverse out
of the child.

Along with this, there are some problems with "directory only"
ignore rules on container directories.  Given "a/*" and "!a/b/c/"
(where the second rule is a directory rule but the first rule is
just a generic prefix rule), then the directory only constraint
was having "a/b/c/d/file" match the first rule and not the second.
This was fixed by having ignore directory-only rules test a rule
against the prefix of a file with LEADINGDIR enabled.

Lastly, spot checks for ignores using `git_ignore_path_is_ignored`
were tested from the top directory down to the bottom to deal with
the containment problem, but this is wrong. We have to test bottom
to top so that negative subdirectory rules will be checked before
parent ignore rules.

This does change the behavior of some existing tests, but it seems
only to bring us more in line with core Git, so I think those
changes are acceptable.
pack: remove misleading comment
pack: do not repeat the same error message four times

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.
pack: unpack using a loop

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.
pack: use a cache for delta bases when unpacking

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.
pack: make sure not to leak the dep chain
pack: preallocate a 64-element chain

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.
pack: simplify delta chain code

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.
pack: expose a cached delta base directly

Instead of going through a special entry in the chain, let's pass it as
an output parameter.
pack: use stack allocation for smaller delta chains

This avoid allocating the array on the heap for relatively small
chains. The expected performance increase is sadly not really
noticeable.
pack: don't forget to cache the base object

The base object is a good cache candidate, so we shouldn't forget to add
it to the cache.
Merge pull request #2346 from kitbellew/fix2300

Minor fix for previously merged netops code.
Merge pull request #2330 from libgit2/cmn/pack-unpack-loop

Make pack object lookup use loops
Merge pull request #2328 from libgit2/rb/how-broken-can-ignores-be

Improve checks for ignore containment
Fix mkstemp on Win32.

It only opened the file for writing; normally, the function is expected
to create a file for reading as well and apply 0600 as the permissions.

See, for instance:
http://man7.org/linux/man-pages/man3/mkstemp.3.html
Add ftruncate() adapter.

This p_ftruncate() method will be used with mmap segments open for
writing since mapped file might need to be extended first and then,
if necessary, truncated at the end.
Make sure mmap can be used for writing.

In Win32, use explicit maximum size; in order to avoid having to stat
and, more importantly, to be able to extend mapped file when writing,
use the end of the explicitly requested buffer.

Also, expose the page size, to be able to write in manageable chunks.
Add convenience methods for writing mapped blocks.

Implement a small set of operations on write-only data (seek, write,
unmap and close).
Use mmap to write to indexer packfile.

Make sure to open the packfile for reading and truncate when done.