Set main properties for the input arguments

This change is to starting point to pass the profile
inputs as a table workspace

Previously the profiles were accessed through a list of bespoke dataclass
objects called NeutronComptonProfile.
Made the change to use a table workspace instead, to conform with the new
input argument.
Still need to change the way the Joint routine links profiles together.

Cleaned some unused comments from previous changes to the code.
Made tests use routine object directly without having to go through
the AlgorithmManager, this makes sure we can access results from a
public method.

Initialize fit parameters and bounds when setting up the class.
This makes it easier to keep track of the order in which the masses are
getting into the parameters array and makes it easier to change it in the
future.

Made self._masses method because it is used several times across the routine.

System tests are sliglty off so I increase the tolerance to have them pass.

Added unit tests and removed old comments

Transformed existing function to create a function that takes
in an outputs table containing the means at the end of the routine and
passes these to the inputs profiles table as the initial parameters.
The lightest mass is always unfixed (bounds are relaxed).
The h ratio is used depending on whether the sample contains hydrogen.

Refactored joint algorithm to fit new approach of using
profiles table as inputs to the AnalysisReduction algorithm.

For consistency sake, I changed all of the suffixes of the
workspaces to lower case and abreviated longer terms where possible.
This makes the workspaces easier to read and looks a bit tidier.

When h ratio is not provided and hydrogen is present in the sample,
the routine for estimating the h ratio to the lowest mass is triggered.
Had to update this routine with the changes from converting vesuvio analysis into
a mantid algorithm.

Used logging instead of print, also formatted the logging statements better.

Previously the constraints argument was disabled because
I did not find a way to pass Python objects (tuple of dictionaries) into
the mantid algorithm.

This workaround converts the tuple of dictionaries into a byte string
using the dill library which can then be converted to a normal string and
passed into the mantid algorithm as an argument.
When the algorithm executes, the string is converted into byte string again
though eval() and then into the tuple of dicts of lambdas by the dill library.

A better solution might be implemented in the future but this will suffice for now.

The fittnig routine was failing due to the naming conventions having
changed. Updated routine so that it finds the correct ncp workspaces.
Updated the system tests.

Cleaned up some comments, and introduced some others for clarity.