- Remove responsibility to store the Hamiltonian on the COO sparse matrix
  format from the HoppingAmplitudeSet. Likely solution: Make the
  HoppingAmplitudeTree or HoppingAmplitudeSet responsible for on the demand
  constructing and returning a SparseMatrix. The HoppingAmplitudeTree is
  complex in itself, and probably it is therefore better to let the
  HoppingAmplitudeSet take on this responsibility. This should also result in
  the copy and move constructors, destructor and assignment and move assignment
  operators to no longer be needed. Further, this removes the need on the
  Solver::ChebyshevExpander to override the metodh Solver::setSolver().

- The BlockDiagonalizer does not work for Models with a single global block.
  Fix the BlockDiagonalizer so that it does not crash when using for example
  the Model generated by "model << HoppingAmplitude(1, {1}, {0}) + HC".

- Make AbstractProperty constructor take a vector of ranges instead of a c-type
  array.

- Implement support for serialization for all primitive data types,
  Serializable, and pseudo-Serializable classes.

- Review the design of AbstractProperty. The class currently probably exposes
  too much of its internal structure and also requires the user to be aware of
  the IndexDescriptor when creating new AbstractProperties using the enum class
  IndexDescriptor::Format..

- Add serialization for Property::GreensFunction.

- Modify IndexDescriptor::setRanges() so that it takes an std::vector<int>
  instead of a c-type array and a dimension. IndexDescriptor::getDimensions()
  is also superfluous as this can be better determined from the size of the
  ranges returned by IndexDescriptor::getRanges().

- Move Matsubara related information from specific PropertyExtractors to
  PropertyExtractor::PropertyExtractor.

- Remove variables such as hint and energies from the PropertyExtractors that
  are used to communicate information between the calculateXXX-functions and
  the XXXCallback-functions. Instead pass a hint parameter as argument through
  the calculate() and callback functions. This will allow the same
  PropertyExtractor to be parallelized as long as the solver allows for this.
