[WIP] Add TPT to mixtape

So the msmbuilder2 code has these functions:

        def _ensure_iterable(arg):
        def _check_sources_sinks(sources, sinks):
        def get_top_path_scipy(sources, sinks, net_flux):
        def get_top_path(sources, sinks, net_flux):
        def get_paths(sources, sinks, net_flux, num_paths=np.inf, flux_cutoff=(1-1E-10)):
        def _get_enumerated_paths(sources, sinks, net_flux, num_paths=1):
        def _find_top_paths_cut(sources, sinks, tprob, num_paths=10, node_wipe=False, net_flux=None):
        def _Dijkstra(sources, sinks, net_flux):
        def _back_relax(s, b, pi, NFlux):
        def _backtrack(B, b, pi, NFlux):
        def find_path_bottleneck(path, net_flux):
        def calculate_fluxes(sources, sinks, tprob, populations=None, committors=None):
        def calculate_net_fluxes(sources, sinks, tprob, populations=None, committors=None):
        def calculate_ensemble_mfpt(sources, sinks, tprob, lag_time):
        def calculate_avg_TP_time(sources, sinks, tprob, lag_time):
        def calculate_mfpt(sinks, tprob, lag_time=1.):
        def calculate_all_to_all_mfpt(tprob, populations=None):
        def calculate_committors(sources, sinks, tprob):
        def calculate_fraction_visits(tprob, waypoint, source, sink, return_cond_Q=False):
        def calculate_hub_score(tprob, waypoint):
        def calculate_all_hub_scores(tprob): ```

We need to decide which ones we want to keep in mixtape. I came up with the following decomposition:

paths.py : contains code for finding paths from a net flux matrix
fluxes.py : contains code for computing flux matrices (and commitors) from an msm
mfpts.py : contains code for calculating mfpt's from an msm
hubs.py : contains hub-score stuff

So, I think the first three we should definitely keep. We can debate the last one (@tjlane, do you care?)

I don't think any of these really make sense as an estimator (and the current API doesn't really fit that anyway since they'd be transforming an MSM, which is not a transform of sequences), so I'm just going to have a bunch of functions.

Finally, for the path stuff as we debated in pandegroup/msmbuilder#257, there will be two algorithms for computing multiple paths:
1) bottleneck : find the next path by removing the bottleneck of the last path calculated 
2) subtraction : subtract the flux of the path (bottleneck flux) from *all* edges in the last path

I'll probably set (2) as the default.

Do we require integers?  Shape?  Number of dimensions?  Given that we do `array().astype('int).reshape((-1,))`, I just want to make sure people don't pass insane arguments.