Add quickstart documentation.
Reorganize code for Cythonization.

Upcoming C and Cython code will add several files to the
RiemannSurfacePath construct. We segregate this code for
organizational purposes.
Cythonize Smale's alpha theory.

The functions required for performing Smale's alpha theory,
including Cython classes for fast polynomial evaluation,
are added via smale.pyx.

Some performance notes / considerations:

* It is possible to release the gil in UnivariatePolynomial
  .eval but we can't in MultivariatePolynomial until a
  C/Cython method of storing the polynomial coefficients
  is found.

* Until the gil is released in MultivariatePolynomial.eval
  we cannot release the gil in any of the smale_*
  functions. This all seems to boil down figuring out the
  best way to store a list of Cython classes.

For now, this looks like a decent implementation. Some
preliminary tests show that polynomial evaluation is
approximately x10 faster and that Newton iteration is
much much faster. (At least x100?)
Move Smale alpha constant.
Fix __init__.py's and import paths.
Fix abs bug in smale.

cabs() is the appropriate function for computing the absolute
value of a complex type.
Naive integration of Cythonic Smale to paths.

Now that all of the Smale's alpha theory is Cythonized we
naively integrate it into RiemannSurfacePath. That is, we
perform no Cythonization of data types withing RSPath other
than the necessary one: RSPath.df, the y-derivatives of
the curve.

The next step will be to incrementally improve performance
within the class, itself.
Standardize timing tests.

We perform some timings:
1) %time X.period_matrix()
   (Note that this is timed after computing X.homology() and
   X.holomorphic_differentials())
2) %time monodromy(f,x,y)
Cythonize x-paths and attributes of RS paths.