Missing modules for new geometric digitization

[asalzburger]

As discussed in an email @noemina and @niermann999, there are still some missing components needed in the new geometric digitization.

/// Configuration struct for geometric digitization
///
/// If this is defined, then the geometric digitization
/// will create clusters with cells.
/// The BinUtility defines the segmentation and which parameters
/// are defined by this.
///
struct GeometricDigitizationConfig {
  std::vector<Acts::BoundIndices> indices = {};
  Acts::BinUtility segmentation;
  /// Drift generation
  DriftGenerator drift = VoidDriftGenerator{};
  double thickness = 0.;
  /// Charge generation
  ChargeGenerator charge = VoidChargeGenerator{};
  double threshold = 0.;
  /// Position and Covariance generation
  bool digital = false;
  CovarianceGenerator covariance = VoidCovarianceGenerator{};
};

As you can see, the three generators are not (yet) meaningful, they only are implemented as Void*Generator.

1. DriftGenerator

using DriftGenerator =
    std::function<Acts::Vector3(const Acts::Vector3&, RandomEngine&)>;

This generator takes a position and a random number engine and generates a drift direction in the local 3D frame:

• any Vector3(a,b,c) with (a,b) different from (0.,0.) will create a drift

A simple implementation would be a constant drift for every module, a more complicated one calculates the Lorentz angle, etc. I think these two generators would be enough.

2. ChargeGenerator

using ChargeGenerator = std::function<Acts::ActsScalar(
    Acts::ActsScalar, Acts::ActsScalar, RandomEngine&)>;

This generator takes two scalars, the first is the path length in a pixel, the second the drift length to the surface,
the idea of this generator is to transform it into a charge, such that the threshold can be applied. The RandomEngine allows for smearing of this.

3. CovarianceGenerator

using CovarianceGenerator =
    std::function<std::vector<Acts::ActsScalar>(size_t, size_t, RandomEngine&)>;

This Generator takes the cluster size in loc0 and loc1 and a random engine and returns a covariance matrix.
A simple digital generator could just do pitch/sqrt(12) (but is incorrect), ideally we could have a parameterised version(see below) of the covariances attached to each module and depending on a size lookup it picks out the right covariance entry.

The way these generators work is that you implement a struct that is callable and has the right interface.

4. DigitizationAlgorithm & Validation Code Update

Additionally, we need to write a new collection from the DigitizationAlgorithm, which contains the raw data, i.e. the cell information. The RootDigitizationWriter should then be updated to check if this collection is retrievable and if so, add the cluster size information to the root output.

The Io/Csv output has to be updated then as well.