Added Molecule.getNumberOfRadicalElectrons() for counting radicals.

In this function, monoradical atoms count as one, biradicals count as two,
etc.
Updated Molecule.getNumAtoms() with a bit of Cythonization.

This function may be called quite a bit more often, and speed may become
important.
Generate reactions now allows constraints on the generated species.

These are passed as (optional) keyword options to various methods used to
generate reactions. The keywords allow for control of the maximum number
of C, H, O, N, Si, and S atoms, the total number of heavy (non-H) atoms,
and the total number of radicals.

Note that RMG-Java also allows for setting the maximum number of cycles,
but I've left this out for now since finding cycles is considerably more
expensive than counting elements and radicals.
Added generatedSpeciesConstraints() block to RMG input file.

This optional block allows the user to set constraints on the species
generated during RMG jobs. The allowed constraints are:
maximumCarbonAtoms, maximumHydrogenAtoms, maximumOxygenAtoms,
maximumNitrogenAtoms, maximumSiliconAtoms, maximumSulfurAtoms,
maximumHeavyAtoms, and maximumRadicalElectrons.

These constraints are stored in the new reactionGenerationOptions
attribute of the CoreEdgeReactionModel class. The contents of this dict
are passed to KineticsDatabase.generateReactions() as the options so
that they may be enforced during reaction generation.

The expectation is that, if used, this should provide a significant speed
boost to many RMG jobs by eliminating graph isomorphism evaluations for
large molecules, which are known to be slow.
For reacting A + A, make a copy of A once for all families.

This is necessary to allow the two copies to be manipulated independently.
Before we were doing this in each call to __generateProductStructures(),
which meant it was occurring twice per family. Deep copies of molecules are
expensive, and this eliminates some of them.
Remove needless deep copy of reactants in KineticsFamily.__generateReactions().

These are only a small contributor to the number of deep copies of
molecules made, but every little bit helps.
Possibly faster version of Graph.copy().

We spend a lot of time making deep copies of molecules, so any speed boost
here would be valuable. (This is the tradeoff we made in making the
graph isomorphisms themselves faster.) In this commit we eliminate the
expensive calls to list.index(), instead keeping a dict with a mapping of
vertices from the original to the copy.
Tentatively removed more unnecessary calls to Molecule.copy().

We don't need to copy the product molecules again when creating reactions
because we already did that when generating product structures.
Added KineticsFamily.isMoleculeForbidden() method.

This encapsulates functionality for determining if a molecule is forbidden
in a kinetics family, which is currently being checked in multiple places.
Better checking for forbidden structures when generating reactions.

In __generateProductStructures(), the reactants are checked before the
recipe is applied, as there is no point in generating the products if
the reactants are forbidden anyway. Also removed a redundant check of the
product structures from __createReaction() which was already covered in
__generateProductStructures().