This allows us to separate accidentally unused, from explicitly unused
parameters, which allows us to turn on such checks in the compiler.

The generally recommended way is to include it from source files, not
headers. We had a mix of both. Let's try to be consistent and follow the
recommended way.

Result of overflow on signed integer arithmetic is undefined in C/C++ standard.
So in previous version clang was compiling the statement as (int)a > (int)b (i.e. assuming no overflow), which leads to incorrect result.

Correct deterministic behavior means doing overflow arithmetic as unsigned, i.e.
 a != b && a - b <= UINT_MAX / 2

If we are still in slow start then we haven't discovered the actual
bandwidth limit yet. We also rely on the caller causing a bit of
congestion to detect the limit. So report a higher bandwidth estimate
than what we've currently tested in this scenario.

Fixes #652.

We don't want to waste bandwidth on the lossless refresh if we might
need that bandwidth for a normal update. Try to estimate how much
data we can safely send without interfering.

Allows us to compare our computed congestion window with the
underlying one used by the TCP layer.

Refine the previous method by interpolating the values we need.
This reduces the effect of the problem that we cannot send enough
ping packets.

It's a general function and it's better to have that particular
complexity in its own place.