State Data will hold the old and new solution (as usually)

We'll have a kold vector of MFs, of size m, and a knew vector of MFs,
also size m

MF vectors:

k_new[SDC_NODES]: this is the new solution at the nodes in the time
                  integration

   * k_new[0] -> S_old : we never update this, so it can just be a ref
   * k_new[1] -> new MF
     ...
   * k_new[SDC_NODES-1] -> new MF

   At the end of the who update, k_new[SDC_NODES-1] will be copied into
   S_new


A_old[SDC_NODES]: this is the old value of the advective update at the
                  nodes of the time-integration.  It is needed to
                  compute the quadrature using the old solution in the
                  node update.

    * A_old[0] -> new MF
      ...
    * A_old[SDC_NODES-1] -> new MF


A_new[SDC_NODES]: this is the new value of the advective update at the
                  nodes of the time-integration.  We are storing this 
                  so that at the start of the next iteration we can
                  copy A_old <- A_new as needed for the quadrature.

                  Technically, we don't need to store this as a MF, we
                  could (at the cost of the computation) recompute A_old
                  at the start of a new iteration by calling the advection
                  machinery on k_new.

    * A_new[0] -> A_old[0] : since the old time doesn't change, these are the same
    * A_new[1] -> new MF
      ...
    * A_old[SDC_NODES-1] -> new MF


R_old[SDC_NODES]: this is the old value of the reaction source, again
                  needed for the quadrature over the old solution

    Since this is just an instantaneous RHS evaluation, we will
    compute this on the fly at the top of the timestep using k_new
    (which is now the "k_old").  We need to update this at the start
    of the timestep, before k_new is updated, so our quadrature over
    the old interation is defined.

    * R_old[0] -> new MF
      ...
    * R_old[SDC_NODES-1] -> new MF



We will use the "new" time solution in the StateData as our work space,
copying knew[m] into it when computing the update for m+1.  This allows
us to fill ghost cells and compute the advective term based on knew[m].

We will also need a vector of m MFs, Aold, to store the advective
terms at the old iteration (kold).  Note: we cannot update these as we
do an update from m to m+1, since the integral in the SDC update
should all be at the same iteration.

None of kold, knew, or Aold need ghost cells.



----

for the 4th order we will add a StateType, SDC_Source_Type, _only_ if
castro.fourth_order = 1 and castro.time_integration_method = 2

we would not add it directly to the enum, so there is nothing to be done
if we are not using this.

Then we would only keep one time level, by adding a clause in
swap_state_time_levels()

This will be used to fill the ghost cells for the RHS of the update
(what we've been calling C).
