We wanted to try and speed up the CI tasks for the Rails Template.

This work introduces the same approach we took to save time on the DfE
Complete project.

We use Docker supplied actions to build the image and cache the layers
to the Github actions cache.

Subsequent jobs are set to use the layers from the cache which, in most
cases, gives us a nice speed boost.

We've split the jobs so they can be run in parallel, as we know the
image is the same for each job they all use the strategy.

We've kept the Shellcheck task separate as this code is not strictly
speaking the application code, so doesn't really need to be inside the
image.

Now that we have all the CI tasks in Github Actions these scripts are
never used.

This adds a composite action to run the two cache-loading steps that are
reused across three of the jobs in the continuous integration workflow.
The second of these steps is a little long and detailed, and differs
slightly but meaningfully from a similar step in the build cache job, so
it might be useful to DRY this up. This also allows us to see the meat
of the post-cache jobs a little easier in the continuous integration
workflow

The `actions/checkout@v4` step is needed in each job in order to load
our action (and presumably also the external ones used in the composite
action)

It would be quite nice to use a YAML anchor or alias to do this kind of
reuse, but these are currently unsupported in GitHub Actions. They might
be on the way soon, so watch this space: actions/runner#1182

Our caching strategy is to cached across CI jobs with the focus on
caching the layers in the Docker image.

As each job has to build the image from (using the cache) regardless, we
think we can get rid of the independent build and cache job and let the
caching happen as we run each job.

The only way to see if this pays off is to merge the changes and run
another CI workflow to see how much caching we get.

We have also split each linter and formatter into their own `run` steps,
this is for clarity.