Create classes to represent ionization state distributions - #404

I extended the docstring, clarified some NotImplementedErrors,
implemented slicing, set __repr__, and slightly extended tests.

I added a bunch of attributes and methods plus a bunch of checks, and
I think allowed this to be iterated.  I'm still not sure about what
the best names are for the different attributes, and a lot of what is
included in this so far is up in the air.  I'm not sure if we want to
include a way to calculate collisional ionization equilibrium since
that would require a lot of data to be stored by the package somehow,
but that would be really useful and something that would probably be
used a lot by plasma physicists.

I added the capability to iterate over charge states, in which case I
used a `collections.namedtuple` with different attributes for the
integer charge, ionic fraction, and ionic symbol since these are the
most relevant values.  It might end up being reasonable to include the
number density in here too, if available.

Prior to this, I had set separate `rtol` and `atol` keyword arguments
and attributes for use with numpy.isclose.  I changed this to a sole
`tol` attribute because (1) for checking the normalization, absolute
and relative tolerances reduce to the same thing because the relative
tolerance is relative to one, and (2) for tiny abundances, the
absolute tolerance will be more relevant than the relative tolerance.
In calls to numpy.isclose, I explicitly set `rtol` equal to zero so
that it's clear that we're dealing with absolute tolerances and not
relative tolerances.

I defaulted `tol` to 1e-15 since at 1e-16 I got errors with
np.isclose.

Before this, I had IonizationState[value] return just a float for the
ionization fraction.  Now it returns a namedtuple with the integer
charge, ionic fraction, and ionic symbol.  This change is because the
integer charge, ionic fraction, and ionic symbol are all likely to be
needed, and to be consistent with the behavior as an iterator.

It may be worth changing this namedtuple (presently named State) into
a class.  There's also a need to create an IonizationStates class that
includes more elements.

I noticed that using isinstance(n, int) was returning False when n was
a numpy.int64 object, for example.  On the World Wide Web™ I found we
could instead do isinstance(n, (int, numpy.integer)).  I made this
change in a bunch of atomic modules for Z and mass_numb.

I did not yet change the docstrings or type hints to reflect that
numpy.integer types are allowed, and am debating whether or not it
would be best to do so.  The docstrings and type hints will be more
explicit with allowed types if we say that numpy.integer types are
allowed, but the docstrings and especially the type hints will get
more difficult to read.  It would be helpful if we could make this
notation more compact.  If we end up checking type hints with mypy, we
might need to at least update the type hints.

…-state

This class holds ionization state distributions for multiple elements,
unlike IonizationState which holds ionization state distributions for
just a single element.  I started adding attributes and docstrings,
including a way to input the ionization state data.