Add a preflow–push maximum flow algorithm

I noticed that there was a two-year-old Issue (networkx/networkx#550) about preflow–push (or push–relabel) algorithms, but apparently those algorithms were never included in any releases. Comments under the Issue showed some discouraging running times. But I think that it is still useful to have them integrated because many papers (e.g., [1]) have suggested the advantage of preflow–push algorithms over the Ford–Fulkerson algorithm.

I was unable to locate the implementations referenced in the Issue, so I went ahead to write one. I picked the highest-label variant with the global relabeling and gap heuristics.

Running [compare_relabel.py](https://networkx.lanl.gov/trac/attachment/ticket/558/compare_relabel.py) from the Issue shows an improvement:

```
nx.preflow_push                    0.572 s
nx.ford_fulkerson                  1.461 s
```

Running the 18 DIMACS cases used in [1] shows greater speedups for the larger ones:

```
==========================================================
                                   preflow_push
        ford_fulkerson   --------------------------------
                          @003a541   @e4f35ad   @cb655f9
----------------------------------------------------------
 GL1            1.38 s      0.20 s     0.15 s     0.12 s
 GL2            4.05 s      0.33 s     0.28 s     0.23 s
 GL3           17.62 s      1.56 s     0.99 s     0.80 s
 GL4           66.50 s      1.97 s     1.81 s     1.27 s
 GL5          310.80 s      5.84 s     4.05 s     2.96 s
 GL6         1532.13 s     15.52 s     9.29 s     6.82 s
----------------------------------------------------------
 GW1            0.52 s      0.44 s     0.43 s     0.34 s
 GW2            2.52 s      1.19 s     1.12 s     0.72 s
 GW3            7.86 s      2.42 s     2.30 s     1.83 s
 GW4           34.39 s      5.90 s     5.57 s     4.14 s
 GW5          166.30 s     17.20 s    15.61 s    11.23 s
 GW6          870.59 s     43.72 s    41.07 s    29.68 s
----------------------------------------------------------
 WLM1           0.10 s      0.04 s     0.03 s     0.03 s
 WLM2           0.43 s      0.16 s     0.09 s     0.06 s
 WLM3           1.39 s      0.16 s     0.16 s     0.12 s
 WLM4           7.89 s      0.46 s     0.45 s     0.34 s
 WLM5          43.31 s      2.32 s     1.47 s     1.16 s
 WLM6         190.64 s      5.72 s     4.18 s     3.28 s
==========================================================
```

Interestingly, the running times of the GL and WLM cases above, measured using Python 3.4 on a Xeon E5530, are longer than those found in [1], which were collected almost 20 years ago on a DECsystem 5000. I suspect that constant factor optimization is possible such as reducing dictionary lookups. But perhaps the user can take a look at a C++ implementation like [Boost.Graph](http://www.boost.org/doc/libs/release/libs/graph/) if he/she needs to deal with very large problems.

##### Reference
1. Ahuja, R.; Kodialam, M.; Mishra, A. K.; Orlin, J. B. (1997). "[Computational investigations of maximum flow algorithms](http://dx.doi.org/10.1016/S0377-2217(96)00269-X)". *European Journal of Operational Research*, **97** (3): 509–542.