Dub.loadPackage: Error out if no recipe is found ...

Before, due to calling Project.this(PackageManager, NativePath),
using loadPackage when no PackageRecipe exists would lead to
an error message being printed from the ctor and the Project
being initialized with an empty recipe.
Such a behavior should not be implicit - instead, we will now
error out directly from loadPackage if no Package is found.

A nice side effect is that it also allows us to re-defined
one overload in terms of the other, simplifying subclasses
implementations.

platform: add support for LoongArch

Trivial: Simplify Project.reinit by removing nested functions ...

When 95% of your function is nested, you're doing it wrong.
Move the function to be at the class level and private,
which makes the logic easier to follow and reduces indentation.

Trivial: Document Project.reinit ...

Arguably one of the most important method on the package management
front, as it is handling the logic of what dependencies will be used
in most cases (the DependencyResolver is only called when deps are
missing, but most projects have a dub.selections.json).

Deprecate `Package.load`, use `PackageManager.load` instead ...

In order for the dependency injection approach to work,
we need to be able to override every single instance of
`Package.load`. We could not override `Package.load` itself
as it is a static function.
However, in the process of adding support for path-based dependencies
to the test suite, it became obvious that the functionality offered
by `Package.load` is actually better suited for the `PackageManager`.
Deprecating `Package.load` confirms this: Not a single call was outside
of `PackageManager`, and no extra parameter had to be provided anywhere
to make this work.
This also nicely simplifies the `TestPackageManager` implementation,
as we can now overload `load` and let `getPackage` alone.

Merge pull request #2771 from ibuclaw/merge_stable ...

update version to v1.36.0-beta.1

Merge remote-tracking branch 'upstream/stable' into merge_stable

update version to v1.36.0-beta.1

Merge remote-tracking branch 'upstream/master' into stable

Merge pull request #2768 from ibuclaw/merge_stable ...

merge stable

Merge remote-tracking branch 'upstream/stable' into merge_stable

update version to v1.35.1

Test framework: Add documentation and an example UT

Deprecate Project.packageManager ...

There is no reason to expose the PackageManager through the Project.
In fact, the only two places it was used were in generators,
where the PackageManager was stored but never used.
The generators arguably should not have access to the PackageManager,
as all the Packages should have been loaded and handled to them
before the generation starts.

Remove fallback to ~master on dub fetch, fix #2679 ...

The retry does not make sense, as one cannot add a package
to the registry without a release version.
It is also not in line with Dub strategy, as we are trying
to reduce the usage of branch dependencies.

This also fixes issue #2679 which pointed out the error message
was sub-par. The API of the registry seems to have changed and
we now get `null` instead of `undefined`, leading to an error
inside the JSON module instead of the enforce being triggered.

Fix #2696: Segfault with bad dub.sdl ...

This was a null pointer being passed down.
However, while looking at the code, it was obvious that similar
bugs would trigger for subpackages (as the code was not handling
`null` packages either), so test cases for those have been added.

Test framework: Return fully typed TestPackageManager from TestDub ...

Using covariant return type, we can avoid the need to change the base class,
and leave all the overloading in the child class.

Add unittest framework and some dependency tests ...

Dub has always been notoriously hard to test due to the amount of IO it does.
Over the past few years, I have progressively refactored it to allow
dependency injection to take place, which this finally put into action.
By overriding the `PackageManager`, `PackageSupplier`, and a few strategic
functions, we can start to unittest Dub's behavior solely in unittests.
This should hopefully tremendously helps with adding regression tests
for the package manager side of Dub (the build side still need work
to have similar capabilities).

Allow dependency injection on the PackageManager ...

We want to allow one to provide their own PackageManager instance.
There are 3 standard ways of doing this:
1) Provide an instance in the constructor;
2) Provide a template parameter;
3) Use a hook that is called by the constructor;

We are going with option 3 as the other two methods have clear downsides:
Option 1 exposes too much of the implementation detail (even if it can
be wrapped by another constructor) and makes the dependency to internal
state hard / impossible (we need to instantiate SpecialDirs then load
the config that may modify SpecialDirs).
Option 2 is even worse as it exposes implementation details to the type
and makes OOP impossible (e.g. method accepting a `PackageManager`
need to be changed). Option 3 is the best compromise, as its main downside
is that it requires to create a new `Dub` type, however that is already
required due to the amount of configuration points that do IO
(loadConfig, determineDefaultCompiler, computePkgSuppliers).

Allow dependency injection on the PackageSupplier ...

In order to make the `Dub` class properly unittest-able,
we need to be able to use a non-default `PackageSupplier`,
in particular one that would not hit the registry or the filesystem.
This can be achieved by moving a free function to a method and having
derived class override it, as shown in this commit.

Move TestDub to its own module ...

As we will begin to inject more dependencies, having a base module makes sense.

Make inheriting from Dub easier ...

This would make extending TestDub much easier by exposing the class fields,
the common initialization routine, and a configuration point.
It also allows us to move TestDub to another module.

Trivial: Use public interface, not field names, in unittest ...

This would make moving this unittest to another module easier.

Trivial: Rename computePkgSuppliers to makePackageSuppliers ...

This is consistent with the naming of other factory functions.

Trivial: Shorten a few parameter names ...

The parameter names were repeating the type name,
which in a language like D does not make sense.

Trivial: Make `TestDub` non-final ...

There is no reason to limit inheritance on this class.

Allow to load dub.selections.json before Project instantiation ...

The aim of this commit is to have at least one constructor
for Project that does not perform IO. By moving the IO to the
`Dub` class, we can keep the dependency injection in `Dub`
and `PackageManager` only, and don't have to specialize `Project`.

Trivial: Remove a dependency to std.path ...

Use the Dub versions instead.

Trivial: Merge two related unittest in dub package ...

They both test computePackageSuppliers in the end.

Refactor loadConfig to not rely on class state ...

By making it take a parameter and return a value, we make it
more obvious what is being used and changed, and we document
that rootPath is the only class member being read,
which is a fair assumption for any method of Dub.