`list.sort` enhancement proposal: Adaptivity for `binarysort`

Note:

1. This is POC that this has a observable impact.
2. This is subject to further calibration and optimizations, but high level concept is dicusable.
3. Will issue PR shortly.

Rationale

Galloping provides adaptivity when merging runs.
However, underlying binarysort always does O(nlogn).

Concept

The concept is simple:

1. binarysort optionally does adaptive routine.
   1. It has a mechanism to switch it off during the run and go to simple binarysort
   2. It returns 1 if it has completed full data with binary routine and 0 otherwise
2. timsort calls binarysort
   1. If it returns 1, then use it again next time
   2. If it returns 0, then use binarysort without adaptivity next time
   3. increase number of simple binarysort runs before next attempt of adaptive run with every 0 returned

High level results

• A0 is current
• A1 is with adaptivity
• P means performance / runtime
• C means comparison count
• Aggregate numbers for all datasets combined are in the title

1. Plain integers and floats

2. Integers and floats wrapped in list, so comparisons are __lt__ calls, thus more expensive

So the benefit is higher when comparisons cost more.
But there is some benefit for optimized comparisons as well.