API refactoring + API tests and checks

[TarekAbouChakra]

This PR focuses on NePS API refactoring and introduces several enhancements and tests:

• YAML generated to save optimizer information is now better configured, with specific details on the optimizer's arguments and the type of search done.
• Added test cases for each neps.run call type, covering Baseoptimizer, default YAML, and user YAML scenarios.
• Introduced a Metahyper test for the optimizer, evaluating multi-thread processing and pausing/resuming run scenarios. This test ensures that users won't unintentionally use different searchers for the same run, providing a more stable and predictable optimization environment.
• Added API tests on GitHub Actions.
• Accepts None to be passed for the pipeline space when the searcher is of type BaseOptimizer. Raises an error otherwise

[eddiebergman]

Just left some minor comments, don't need to act on them really. I do like the idea that you test runnable examples through pytest, I think going forward this will make it easier to do integration tests and make test writing easier for people.

If you are happy with others using the examples, you could move them to the root, ./examples directory of the repo and still test them there. That way people will see them, use them, and their tested.

[eddiebergman]

Some information about typing, don't need to do anything here but thought it mgiht be good to share:

1. If you have from __future__ import annotations (which there is), you can use the lowercase list
2. Do not use mutable arguments as a default.
3. We can type it better by following down where they're used, from what I gather it accepts Callable[[metahyper.Sampler], metahyper.Sampler], where it can modify the sampler. Consider the typing can happen at a neps level and we only care about class BaseOptimizer(metahyper.Sampler): ..., then the full signature might look like:

def run(
    ...,
    pre_load_hooks: list[Callable[[BaseOptimizer], BaseOptimizer]] | None = None
):
    if pre_load_hooks is None:
        pre_load_hooks = []

4. We can actually improve it even further using typing.Iterable to mean anything that we can iterate

from typing import Iterable

def run(
    ...,
    pre_load_hooks: Iterable[Callable[[BaseOptimizer], BaseOptimizer]] | None = None
):
    if pre_load_hooks is None:
        pre_load_hooks = []

This means someone could pass a tuple, set, generator or really anything where we can go for x in my_iterable: ....

5. Last bit is definitely over the top and low priority, but just to share some new typing tips. The function is actually a bit more specific in that it should return the same type of BaseOptimizer that went into it, not just any base optimizer. We can use TypeVar's for this, which are essentially C+++ Templates or Java Generics.

from typing import TypeVar

# This is some type that must be subclass of BaseOptimizer
OptimizerT = TypeVar("OptimizerT", bound=BaseOptimizer)

def run(
    ...,
    pre_load_hooks: Iterable[Callable[[OptimizerT], OptimizerT]] | None = None
):
    if pre_load_hooks is None:
        pre_load_hooks = []

@Neeratyoy thought you might also like to know about these things if you are reviewing