Created rmgpy.molecule subpackage.

There is enough functionality involving molecules to warrant a full
subpackage. Within the subpackage, feel free to split the content into
several smaller modules to enable faster partial rebuilds.
Moved several modules into the rmgpy.molecule subpackage.

As you can see, we already have several modules devoted to working with
molecules and molecular graphs. This will make them easier to find and
generally clean up the source tree.
Updated references to moved rmgpy.molecule submodules.

Most of the time I think you can just import things from the subpackage
directly, e.g. ::

    from rmgpy.molecule import Molecule, Group, fromAdjacencyList

rather than trying to remember which submolecule these are defined in.
The only exception would be if you are cimporting from a Cython module;
in this case you will need to refer to the full subpackage.
Moved rmgpy.molecule unit test modules into molecule subfolder.

The idea is that the unit test modules should generally be organized
parallel to the main rmgpy modules.
Updated references to moved rmgpy.molecule submodules in unit tests.

All of the unit tests in the unittest/molecule subfolder now run as they
did at the start of this branch.
Created new rmgpy.molecule.symmetry module for symmetry number calculation.

This functionality is complex enough to warrant its own module, especially
when we get around to adding QMTP functionality to RMG-Py.
Split symmetry number unit tests to separate module.

Again, the idea is to parallel the structure of the modules in the
rmgpy.* source tree. Note that, as before, a few of the unit tests fail
because they represent tricky edge cases that the current symmetry number
algorithms do not yet capture.
Removed implicit hydrogens functionality from Molecule objects.

The intent was to conserve memory in some situations by storing the
number of hydrogen atoms adjacent to each heavy atom as an integer,
instead of storing the hydrogen atoms explicitly as Atom objects. (The
idea came from OpenBabel, which has this functionality.) However, this
turned out to be far from nontrivial to implement when dealing with
the many graph manipulation requirements of an RMG job, and I don't think
the memory savings is worth the trouble any more.

There was probably also a time savings in the graph isomorphism
evaluation when comparing implicit to implicit, but I think we can get
at least some of that savings back in other ways.
Removed assorted references to implicit/explicit hydrogens.

Since this functionality no longer exists, we need to remove these
references for RMG-Py to run.
Now storing dict of edges on Vertex and vertices on Edge.

Previously we stored the edges in a dict of dicts on the Graph, and did
not store the vertices on the edge at all. However, the convenience of
having these attributes on the Vertex and Edge objects outweights the
slight increase in memory use.

This is a pretty significant change in approach, and many of the methods
of the Graph class needed modification as a result.
Added new implementation of VF2 algorithm for graph isomorphism.

The new implementation exploits the fact that we are now storing the
edges on the Vertex objects to dramatically speed up the isomorphism
check by significantly decreasing the number of calls into the slow
Python/C API. In earlier tests I was seeing a ~8x speedup in isomorphism
evaluation for Graph objects, and about ~2x for Molecule objects.
Updated symmetry number functions to work with new Graph format.

These functions needed quite a bit of work to adjust to storing the bonds
on the atoms itself. In particular, we now need to make deep copies of
the Molecule object in more places, since adding and removing bonds now
modified the Atom objects. This may need more attention in the future,
but seems okay for now.
Added new rmgpy.molecule.adjlist module for working with adjacency lists.

This functionality is used by both Molecule and Group objects. Before it
was stored in the rmgpy.molecule.group module, a bit of an unfortunate
compromise. Now that rmgpy.molecule is a subpackage, we have space to
place the adjacency list functionality in a module of its own, as done
here.
Updated Atom, Bond, and Molecule to work with new Graph format.

As before, this is mostly updating to reflect that the edges are now
stored on the Atom objects instead of the Molecule objects. Some of the
corresponding unit tests also needed a bit of work.
Updated GroupAtom, GroupBond, and Group to work with new Graph format.

As before, this is mostly updating to reflect that the edges are now
stored on the GroupAtom objects instead of the Group objects. Some of
the corresponding unit tests also needed a bit of work.
Updated molecule drawing functionality to work with new Graph format.

As before, this is mostly updating to reflect that the edges are now
stored on the Atom objects instead of the Molecule objects.
Updated thermo and kinetics database code to work with new Graph format.

Mostly this is creating Bond and GroupBond objects with the two atoms
specified in the __init__() method. The findIsomorphism() and
findSubgraphIsomorphisms() methods also now only return the list of
mappings; this caused a few additional changes in the database code.
Fewer calls to len() in updateUnimolecularReactionNetworks().

It's not actually the calls to len() that are causing this method to be
slow, but it's still better to not make billions of calls if they are not
required. This should not change the output at all.
Now storing pdep networks organized by source on CoreEdgeReactionModel.

This seems like a natural thing to do, since we do similar for species
and reactions already. It should make updateUnimolecularReactionNetworks()
go faster by reducing the network merging algorithm to O(N) from O(N^2).
Only iterate over updated networks when removing reverses from core..

Only the net reactions from the updated networks should have changed,
so there's no need to iterate over the entire list of core reactions.
Hopefully this speeds updateUnimolecularReactionNetworks() up some more.