Converted rmgpy.data.kinetics into subpackage.

The module rmgpy.data.kinetics was nearing 4000 lines of code, which was
by far the largest individual module in the project. There's enough
different functionality to warrant splitting into several modules.
Grouping these under a new rmgpy.data.kinetics subpackage enables other
modules to continue interacting as if it was still a single file.

The kinetics depository, library, and family functionality has been
split into separate modules inside the rmgpy.data.kinetics subpackage.
A module for common functionality is also provided. The main
KineticsDatabase class is placed in the __init__.py since it depends on
all the other modules in the subpackage.
Added module-level lists of unimolecular and bimolecular family labels.

These lists are used only to help load and save the kinetics depositories,
which is why these lists were placed in the depository module instead of
in the common module.

(In the current design, a kinetics depository is a set of real reactions
and their kinetics associated with a family, such as the "training" sets
used to generate group additivity values.)
Removed speciesMatch() helper function from KineticsLibrary.getSpecies().

Equivalent functionality is better provided by Species.isIsomorphic().
(This reflects part of the zen of Python: "There should be one - and
preferably only one - obvious way to do it.")
Also copy reaction reversibility when reading reaction comments from Chemkin.

Otherwise irreversible reactions incorrectly become reversible.
Added readReactionsBlock() to rmgpy.chemkin.

This function handles reading of the reactions and kinetics from a
Chemkin file. It has been split off from loadChemkinFile() so that it can
potentially also be used when loading the RMG-Java kinetics libraries,
which have a Chemkin-like format.
Better handling of units in Chemkin files by readKineticsEntry().

The most important change is that reaction kinetics are now created such
that they maintain the units used in the Chemkin file, rather than
converting everything to cm^3/mol/s and kcal/mol.

The increased flexibility is needed in order to be able to also load
RMG-Java kinetics libraries.
RMG-Java kinetics libraries now loaded via readReactionsBlock().

Since the RMG-Java kinetics libraries are very similar to Chemkin files,
I've worked to merge the two functions together to minimize duplicate
code. This means that we can now load anything from a RMG-Java kinetics
library that we could from a Chemkin file, including Chebyshev and PLOG
kinetics.
Miscellaneous changes to get RMG-Java kinetics library loader working again.

The new Chemkin reactions block parser can now handle comments starting
with, reversible reactions indicated with <=> (as well as =), and the
trio of Arrhenius uncertainty parameters that accompany the high-P
kinetics in the RMG-Java kinetics libraries.

Also, when loading old RMG-Java kinetics libraries, the common bath gases
(Ar, N2, Ne, He) are automatically added.
Make TemplateReaction objects in KineticsFamily.__createReaction().

Before we were making generic Reaction objects in __createReaction(),
then immediately converting these to TemplateReaction objects in
generateReactions(). This change means less duplicate code (and perhaps
a slight speed boost too).
__generateReactions() can now filter reactions that don't match products.

Previously you needed to do this after calling __generateReactions() if
you wanted to only get reactions that match given products. The idea is
that we can make this filtering faster this way, although that part hasn't
happened yet. This is also used in KineticsFamily.calculateDegeneracy().
Move filterReactions() to rmgpy.data.kinetics.

It was in rmgpy.data.kinetics.family, but this module no longer uses it,
while a few methods of KineticsDatabase do.
In __generateReactions(), remove duplicates and incorrect products in one pass.

This should be a bit faster because it avoids redundant work (e.g.
generating product resonance isomers multiple times).
Determine reaction pairs and template inside __generateReactions().

Again, gathering these inside KineticsFamily.__generateReactions() will
hopefully lead to ways to make this code faster.
Temporarily store labeled atoms when generating reactions.

This is done instead of copying the reactants in order to minimize the
number of deep copies of molecules, which are expensive.
Merge branch 'database'