Added proxy weighting #2012

Proposing adding proxy weighting to the current release branch, although I could be convinced otherwise.
> Each pair of elements will only be compared once

I'm pretty sure this assumption is wrong. Below is an example that shows `Collections.sort` actually comparing the same pair of elements twice (4 to 1).  If each of these `compare` calls returns a different result, it's not entirely clear to me what the sort algorithm will do. The safe thing to do is to make sure that within a single `Collections.sort` call, `compare` for any pair of values always returns the same result. This would be quite easy to do by just storing the pairs and random result in a map of some sort on the `Comparator` instance.

```java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

public class SortTest {
    @Test
    public void testIt() {
        List<Integer> l = new ArrayList<Integer>();
        l.add(5);
        l.add(1);
        l.add(4);
        l.add(2);
        l.add(3);
        Collections.sort(l, new C());
        System.out.println(l);
    }

    private static class C implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println("Comparing " + o1 + " to " + o2);
            return o1 - o2;
        }
    }
}
```

Output:

```
Comparing 1 to 5
Comparing 4 to 1
Comparing 4 to 5
Comparing 4 to 1
Comparing 2 to 4
Comparing 2 to 1
Comparing 3 to 4
Comparing 3 to 2
[1, 2, 3, 4, 5]
```