Create delphinus.table subpackage

The plan is to refactor the table readers here. These readers will be
distinct from tables that the user can interact with, which will be
subclasses of astropy Table.
table.readers module for parsing dolphot tables

This new parser module now produces flattened columns. Previously I
would stack photometry from each image into the same column. This might
make things harder to simply output data to a text file. Thus all
image-specific columns in both BasePhotReader and the FakeReader
extension follow the COLNAME_{n} format, where the first image is "0".

Refactored _fill_radec method for FakeReader.

Added a table property to return an astropy table. This may not be
useful as the PhotTable and FakeTable classes will create themselves
from classmethods.
Create PhotTable subclass of astropy Table

The PhotTable.read_phot class method runs the parser to create a numpy
record array that then seeds the table. Since PhotTable is an astropy
Table, all of its methods re available.

We use the metadata to record the number of images, as well as the
names/bandpasses of photometered images. This metadata is available PhotTable
properties image_names and _bands and n_images.

Use the PhotTable.image_col method for reading image-specific columns.
Since the photometery of multiple image is provided in a flat table,
columns such as 'mag' have the image index appended to their name. This
image_col method can resolve and read from the correct column given the
index, image name, or bandpass.
Create FakeTable as astropy Table wrapper

This class inerits from PhotTable, but uses an expanded parser, and also
adds methods for computing completeness fractions and fake star
recovery.

This code is refactored from the old phottable FakeReader class. Now the
reader is clearly separated from the data encapsulation (backed by
astropy Table).

**Note that this will change quality control functions (qcfunc) since we
now pass the table instance itself to qcfunc.**
Refactor StarList into its own module

Moving it into the table package makes sense because this is
intrinsically an I/O module.
Refactor artificial star test reduction in ast.py

The intend of this module is to provide a clean computation engine for
reducing artifial star tests. Will provide a basis for user-facing methods
in PhotTable.

Currently the only function is `compute_errors`.
Remove phottable module

Replaced by modules in the table subpackage.
Rename delphinus as dolphot module
Big refactor of Dolphot class to use new data tables

The new tables can be generated/accesed via the properties phot_table
and fake_table.

Alo used this refactoring/api change as an excuse to make more API
breaking changes that clean up the code and bring PEP8 niceities.
Update global imports from refactor
Create test_phottable.py

Currently this is essentially a burn-in test to read the results from
some WIRCam photometry, constructing a FakeTable and a PhotTable and
compiling AST results.

I've commented out lines to download test data from my S3 bucket because
astropy's download_file() does not seem to cache this data between
tests. I'll want to ultimately ship a more light-weight data set.
Bump version to 0.2.dev
Register PhotTable and FakeTable for I/O

As documented [here](https://github.com/astropy/astropy/issues/1888)
there are currently issues with subclasses of Table since they are now
grandfathered into the astropy I/O registry. Here I've applied the
workaround advocated in [this
gist](https://gist.github.com/joezuntz/7929541). A test of writing and
reading a PhotTable as an HDF5 file is included.
Fix res_fits_path attribute in Dolphot
Generalize PhotTable metadata access for random key cases

This is because reading the table from a FITS file may have random
letter cases for the metadata keys.
PEP8 the registry stuff in PhotTable and FakeTable
Internally encode Table metadata in JSON

If a metadata item is set as a non str/float/int style, such as a list,
then it needs to be encoded as a string. I've chosen to do this with
json encoding.

The metadata is automatically encoded during the read_phot class
methods, and are un-encoded as necessary via the properties. Note that
metadata fields not covered by the properties will not be unencoded.
This could certainly be fixed in the future with some dynamic
properties.
Add FakeTable.vstack

vstack is useful for concatenating results from several artificial star
tests. But using astropy.table.vstack will result in a generic Table,
losing the useful tools of the FakeTable subclass. This FakeTable.vstack
class method will return a FakeTable.
PhotTable.estimate_errors() overwrites prev reductions

When re-doing an AST reduction, we don't need to re-add the
ast_mag_err_i and comp columns. Now we check for it.