Teach httpclient how to support chunking when POSTing request bodies.

Introduce a new http client implementation that can GET and POST to
remote URLs.

Consumers can use `git_http_client_init` to create a new client,
`git_http_client_send_request` to send a request to the remote server
and `git_http_client_read_response` to read the response.

The http client implementation will perform the I/O with the remote
server (http or https) but does not understand the git smart transfer
protocol.  This allows us to split the concerns of the http subtransport
from the actual http implementation.

Allow users to consume a buffer by the number of bytes, not just to an
ending pointer.

Provide a mechanism to add a path and query string to an existing url
so that we can easily append `/info/refs?...` type url segments to a url
given to us by a user.

Move the redirect handling into `git_net_url` for consistency.

(Also, mark all the declarations as extern.)

Clarify what it means to not send a length; this allows us to refactor
requests further.

We can't get a kerberos TGT easily on Windows; skip the negotiate tests.

This conditional was backwards.  We should instead test that clone
returns 4321, not that 4321 returns clone.

Disposal pattern; dispose on completion, allowing us to retry
authentication, which may happen on web servers that close
connection-based authenticated sessions (NTLM/SPNEGO) unexpectedly.

When USE_GSSAPI=OFF, still show information about what SPNEGO is, even
though it's disabled.  This is for parity with other disabled features
like SSH and debugpool that still show details about what is disabled.

The GSS_ERROR(x) macro may expand to `(x & value)` on some
implementations, instead of `((x) & value)`.  This is the case on macOS,
which means that if we attempt to wrap an expression in that macro, like
`a = b`, then that would expand to `(a = b & value)`.

Since `&` has a higher precedence, this is not at all what we want, and
will set our result code to an incorrect value.  Evaluate the expression
then test it with `GSS_ERROR` independently to avoid this.

Attempt to obtain a Kerberos ticket from LIBGIT2.ORG and then clone the
Negotiate-protected site at test.libgit2.org with that ticket.

internal types: change enums from `type_t` to `_t`

libgit2 does not use `type_t` suffixes as it's redundant; thus, rename
`git_http_authtype_t` to `git_http_auth_t` for consistency.

libgit2 does not use `type_t` suffixes as it's redundant; thus, rename
`git_iterator_type_t` to `git_iterator_t` for consistency.

libgit2 does not use `type_t` suffixes as it's redundant; thus, rename
`git_rebase_type_t` to `git_rebase_t` for consistency.

libgit2 does not use `type_t` suffixes as it's redundant; thus, rename
`git_merge_diff_type_t` to `git_merge_diff_t` for consistency.

merge: Return non-const git_repository from accessor method

Do not return free'd git_repository object on error

refs: refuse to delete HEAD

index: replace map macros with inline functions

Regression introduced in commit dde6d9c7.

This issue causes lots of crashes in TortoiseGit.

Signed-off-by: Sven Strickroth <email@cs-ware.de>

This requires adding a new symbolic ref to the testrepo fixture.
Some of the existing tests attempt to delete HEAD, expecting a different failure. Introduce and use a non-HEAD symbolic ref instead.
Adjust a few other tests as needed.

Fixes #5357

Make type mismatch errors consistent

Depending on whether the index map is case-sensitive or insensitive, we
need to call either `git_idxmap_icase_resize` or `git_idxmap_resize`.
There are multiple locations where we thus use the following pattern:

	if (index->ignore_case &&
	    git_idxmap_icase_resize(map, length) < 0)
		return -1;
	else if (git_idxmap_resize(map, length) < 0)
		return -1;

The funny thing is: on case-insensitive systems, we will try to resize
the map twice in case where `git_idxmap_icase_resize()` doesn't error.
While this will still use the correct hashing function as both map types
use the same, this bug will at least cause us to resize the map twice in
a row.

Fix the issue by introducing a new function `index_map_resize` that
handles case-sensitivity, similar to how `index_map_set` and
`index_map_delete`. Convert all call sites where we were previously
resizing the map to use that new function.

Traditionally, our maps were mostly implemented via macros that had
weird call semantics. This shows in our index code, where we have macros
that insert into an index map case-sensitively or insensitively, as they
still return error codes via an error parameter. This is unwieldy and,
most importantly, not necessary anymore, due to the introduction of our
high-level map API and removal of macros.

Replace them with inlined functions to make code easier to read.

win32: fix relative symlinks pointing into dirs

ntlm: prevent (spurious) compiler warnings

Adds support for multiple SSH auth mechanisms being used sequentially