In both `git_win32__stack_format` and `git_win32__stack`, we handle
buffer lengths via an integer variable. As we only ever pass buffer
sizes to it, this should be a `size_t` though to avoid loss of
precision. As we also use it to compare with other `size_t` variables,
this also silences signed/unsigned comparison warnings.

We use the `__LINE__` macro in several places throughout clar to allow
easier traceability when e.g. a test fails. While `__LINE__` is of type
`size_t`, the clar functions all accept an integer and thus may loose
precision. While unlikely that any file in our codebase will exceed a
linecount of `INT_MAX`, let's convert it anyway to silence any compiler
warnings.

When iterating over index entries, we store the indices in an unsigned
int. As the index entrycount is a `size_t` though, this may be a loss of
precision which a compiler might rightfully complain about.

Use `size_t` instead to fix any warnings.

When computing the progress, we perform some arithmetics that are
implicitly converting from `size_t` to `int`. In one case we're
calclulating a percentage, so we know that it should always be in the
range of [0,100] and thus we're fine. In the other case we convert from
bytes to kilobytes -- this should be stored in a `size_t` to avoid loss
of precision, even though it probably won't matter due to limited
download rates.

The memchr(3P) function expects a `size_t` as its last parameter, but we
do pass it an object size, which is of signed type `git_off_t`. As we
can be sure that the result will be non-negative, let's just cast the
parameter to a `size_t`.

When reallocating commit arrays in `opts_add_commit` and
`opts_add_refish`, respectively, we simply pass the const pointer to
`xrealloc`. As `xrealloc` expects a non-const pointer, though, this will
generate a warning with some compilers.

Cast away the constness to silence compilers.

Build with -Werror's equivalent (/WX) on MSVC

Remove warnings

Re-run flaky tests

Our online tests are occasionally flaky since they hit real network
endpoints.  Re-run them up to 5 times if they fail, to allow us to
avoid having to fail the whole build.

Our online tests are occasionally flaky since they hit real network
endpoints.  Re-run them up to 5 times if they fail, to allow us to
avoid having to fail the whole build.

Add the `-Wno-documentation-deprecated-sync` switch when compiling with
clang, since our documentation adds `deprecated` markers, but we do not
add the deprecation attribute in the code itself.  (ie, the code is out
of sync with the docs).

In fact, we do not _want_ to mark these items as deprecated in the code,
at least not yet, as we are not quite ready to bother our end-users with
this since they're not going away.

GetProcAddress is prototyped to return a `FARPROC`, which is meant to be
a generic function pointer.  It's literally `int (FAR WINAPI * FARPROC)()`
which gcc complains if you attempt to cast to a `void (*)(GIT_SRWLOCK *)`.
Cast to a `void *` before casting to avoid warnings about the arguments.

GetProcAddress is prototyped to return a `FARPROC`, which is meant to be
a generic function pointer.  It's literally `int (FAR WINAPI * FARPROC)()`
which gcc complains if you attempt to cast to a `void (*)(GIT_SRWLOCK *)`.
Cast to a `void *` before casting to avoid warnings about the arguments.

MinGW does not define DWORD_MAX.  Specify it when it's not defined.

MinGW uses gcc, which expects POSIX formatting for printf, but uses the
Windows C library, which uses its own format specifiers.  Therefore, it
gets confused about format specifiers.  Disable warnings for format
specifiers.

RtlCaptureStackBackTrace is well-defined in Windows, no need to redefine
it.

For MSVC, support warnings as errors by providing the /WX compiler
flags.  (/WX is the moral equivalent of -Werror.)

Disable warnings as errors ass part of xdiff, since it contains
warnings.  But as a component of git itself, we want to avoid skew and
keep our implementation as similar as possible to theirs.  We'll work
with upstream to fix these issues, but in the meantime, simply let those
continue to warn.

Move `git_win32__file_attribute_to_stat` to a regular function instead
of an inlined function.  This helps avoid header ordering issues and
declarations.

Ensure that the server has not sent us overly-large sideband messages
(ensure that they are no more than `INT_MAX` bytes), then cast to `int`.

Our progress information messages are short (and bounded by their format
string), cast the length to int for callers.

We keep the treebuilder entrycount as a `size_t` - return that instead
of downcasting to an `unsigned int`.  Callers who were storing this
value in an `unsigned int` will continue to downcast themselves, so
there should be no behavior change for callers.

The `git__utf8_charlen` now takes `size_t` as the buffer length, since
it contains the full length of the buffer at the current position.  It
now returns `-1` in all cases where utf8 codepoints are invalid, since
callers only care about a valid length of a sequence of codepoints, or
if the current position is not valid utf8.