Remove PyCXX dependency for core extension modules

I realize that this PR is going to be difficult to review because of its size, but unfortunately, there was no good way to do this in pieces, given how interdependent may of our C++ extensions are.  Rather than reading it all through, it would be helpful to just download, compile and run it in as many contexts as possible.  Note that it's virtually net even in terms of lines of code ;)

In short, this removes the dependency on PyCXX, and uses the direct Python/C API instead (except for `_tri`).  It is tested and working on Fedora 20, Ubuntu 14.4, Mac OS-X Mavericks.  I need some help with Windows testing, particularly since this pushes the limits of the compiler in some places (@cgohlke?).

I skipped the `_tri` module is in part because it's not part of the tangled mess of most of the other extensions, but also because (I think) it's deprecated in favor of `qhull` (which already doesn't use PyCXX).  But, I must admit, I haven't been following the world of triangulation very closely, so maybe we still need to keep `_tri` around for the foreseeable future.  Cc: @ianthomas23  

Most of these modules are declared private, so I took the liberty to change APIs when keeping them as-is would have caused a great deal of pain, but in general, this isn't a wholesale "rewrite" of anything, and really is meant to be mostly a refactor.  The public Python API is unchanged, unless by accident.

An important side benefit of this work is to decoupling the extensions.  For instance, in *master*, the `_image` module passes `Image` objects to the `_backend_agg` module for drawing (this also happens for fonts and text paths).  Now, instead, Numpy arrays are used.  This not only decouples the extensions from one another, it means that the data passed back and forth is a Numpy array and thus can be manipulated from Python much easier (Numpy arrays have a gazillion methods, which our dumb image buffers did not) and with fewer copies in some cases.  So a lot of the methods here like `rgba_to_argb` etc. should become `np.roll` etc.  There's still more work to be done there, and I think that in the long term these sorts of classes should completely disappear.  As it stands, there are already some real benefits, such as saving "upside down" images to a PDF/SVG no longer requires a copy.  Another nice side effect is that the "flipud_out" method, which statefully flips the stride orientation of an `Image` is now gone, since it's much easier/better to do that non-statefully using a Numpy array view.  I plan to refactor this further when I tackle image resampling.

The following methods are gone, since they are just debugging tools, and now that we use Numpy arrays for buffers, it's much easier to poke and prod at the data as Numpy arrays:

- FT2Font::attach_file
- FT2Font::write_bitmap
- RendererAgg::write_rgba
- Image.fromarray2

Thanks to Mark Weibe for his `numpy_cpp` project on which some of this is based.  He agrees that given its small size and matplotlib's somewhat unique needs, it was best to just fork it and include it in matplotlib, so that's what I've done.  At this point, it bears only a subtle resemblance to the original.
Good catch!