Heavily refactor test suite (with Claude)

[Alasdair]

This PR was mostly a weekend learning project to try to figure out for myself the capabilities of AI tools (Claude Code in this case), seeing as everyone is talking/hyped about them and it seems foolish to have a strong opinion without first hand experience.

Here's my (entirely non-AI summary):

• I wanted to remove the duplication of the batch tests/fork loop in each test script. To do this I created a SailTest class in sailtest.py. This class has a run_tests method that handles the main loop. Subclasses override the abstract run method which and can then invoke run_tests as many times as they need. Each time they pass a function to run_tests that is run in the child subprocess and calls step to execute the test actions as before. For example a simplified version of the type check pass script:

@suite("typecheck.pass", work_dir="tcpass")
class TypecheckPassTests(SailTest):
    def run(self):
        self.banner("Testing passing programs")
        self.run_tests(
            "pass",
            Batcher(_PASS_DIR),
            self._test,
            skip_set=skip_pass,
        )

    def _test(self, test):
        test.copy_filename()
        step(
            f"'{self.sail}' --no-memo-z3 --just-check --strict-bitvector"
            f" --ddump-tc-ast {test.filename} 1> _rtpass/{test.filename}"
        )
        # more steps...

This is the end result after many steps (as you can see from the number of commits in this PR)

• I created a single 'entry' point for the tests runner.py, so rather than running test/typecheck/run_tests.py. You now do test/suites/runner.py -s typecheck. There is now some hierarchy, so you can also do -s typecheck.pass. All the python code was moved into a single directory test/suites. Each 'suite' now registers itself using a python decorator. You can use inheritance to share behaviour. The exec tests (renamed from c) demonstrate this quite well, as there is the root SailTest class, then an _ExecCBase class, before the various C and C++ options. Using the decorators was my idea, Claude started doing something really ugly, scanning the file system for python files, loading them and looking for SailTest children dynamically - I had to tell it to use the decorator and registry pattern.

• Separating the code that runs the tests from the test data itself was a nice start, but I also wanted to separate away the output too. Claude actually didn't want to do this - and it turned out it mostly couldn't without making a huge mess of things. Each time runner.py is invoked it generates a new temporary directory and makes a symlink to that in test/_runs. All test output is captured in that directory, with a separate folder for each 'suite'. The thing Claude wasn't able to do was update each script to actually work in that directory, even though it set up most of the infrastructure. I had to port each test suite by hand. Perhaps after doing it myself I could have prompted Claude better, but this was one point where I tried to make it do a 'big step' in the refactoring and it couldn't handle it. The reason this is nice is it makes it much easier to inspect the intermediate outputs of each test, whereas previously because the tests and build artefacts were all mixed we needed to do things like 'rm' intermediate steps to clean up between runs.

I might see if rebasing this PR into a more logical series of commits is something the AI can do. I haven't looked at updating the GitHub actions set so this needs to be a draft PR until that is fixed.