consecutive negotiation

[Byron]

Implement the consecutive negotiation algorithm to be more compatible to other kinds of servers which
cannot deal with the naive negotiation style we currently implement.

Tasks for git-negotiate

• gix-negotiate crate with basic API
• a test to see what happens if negotiation needs multiple rounds for baselines of HAVEs and COMMON and implement noop.
• implementation consecutive
• implementation for skipping
• make consecutive ✅ and skipping ✅ actually work
• add remaining test that also adds known refs for more coverage
• make tests work with --dry-run - wasn't idempotent after all and it only works the first time it's run. There is some state apparently, despite --dry-run.

Tasks for gix

• port multi-round test
• support for adding tips of alternate dbs.
• use negotiator and assure there is an object cache available for the graph traversal. Note that handle should not retry on misses (and do the same for describe). Assure we feed it dereferenced (i.e. peel to commit) commits only.

Research

• Naive is really the first part of the 'common' algorithm which sends most of the refs as specified by the refspec. What's sent next is implemented by the algorithm, which we don't really implement at all.
• with git fetch --negotiate-only it's possible to setup baseline expectations as we see the common commits produced by an algorithm, given a specific input of --negotiation-tips, which is equivalent to controlling the starting point of the negotiation
• noop truly does nothing and is supposed to be used for refetching certain objects if a filter was used previously. It by itself wouldn't even trigger a full pack to be fetched as it also won't put any want line.
• mark_complete_and_common_ref, mark_tips and for_each_cached_alternate (add tips of alternates) is the same sequence both in V1 and V2, then it sense HAVE lines as produced by the negotiator, feed ACK lines to it.
• the first batch is definitely 16, but the window size adapts also depending on the protocol version (to be investigated)
• --negotiate-only does its very own negotiation and thus isn't comparable - probably for V1 compatibility, we want to packet line tracing. However, negotiate_using_fetch provides a clean overview of what negotiation should be.
• The window size for HAVE lines starts at 16, and is then increased with each round according to the rules in next_flush.
• When traversing the commit-graph, which we probably have to do to some extend, the use of generation numbers is optional (and it defaults to INFINITY which effectively turns them off).