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:

```
======================================
        ford_fulkerson   preflow_push
--------------------------------------
 GL1            1.38 s         0.20 s
 GL2            4.05 s         0.33 s
 GL3           17.62 s         1.56 s
 GL4           66.50 s         1.97 s
 GL5          310.80 s         5.84 s
 GL6         1532.13 s        15.52 s
--------------------------------------
 GW1            0.52 s         0.44 s
 GW2            2.52 s         1.19 s
 GW3            7.86 s         2.42 s
 GW4           34.39 s         5.90 s
 GW5          166.30 s        17.20 s
 GW6          870.59 s        43.72 s
--------------------------------------
 WLM1           0.10 s         0.04 s
 WLM2           0.43 s         0.16 s
 WLM3           1.39 s         0.16 s
 WLM4           7.89 s         0.46 s
 WLM5          43.31 s         2.32 s
 WLM6         190.64 s         5.72 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.