Don't call `getPackageIterator` from `loadGitPackage` ...

`getPackageIterator` API forces us to do a refresh, which loads all
packages on the filesystem. However, for `loadGitPackage`'s use case,
we actually can simplify the check quite a bit.

Doing so means that we can now avoid doing a scan for projects
that use SCM-only dependencies.

Test Plan: On master, running the test (without the fix) triggers:
```
core.exception.AssertError@source/dub/test/base.d(790): Trying to access poisoned path: /dub/user/packages/poison/1.0.0/poison/dub.json
```
While with the fix, the test passes.

Let unittest use PackageManager.store ...

No need to mock, all filesystem functions have been mocked
by the PackageManager now.

VFS: Implement file attributes ...

To more accurately reflect the real filesystem,
we now support the access and modification times
for FSEntry.

Test: Make NativePath import public ...

So that tests can use 'NativePath' and 'toNativeString'.

Add the ability to re-invoke Dub with the same vfs ...

This will prove handy when writting tests that require multiple
invocation of Dub, such as idempotence tests, or things like
add-path which currently don't propagate their change through
Dub as they are one shot commands.

Mock IO in writeLocalPackageList / writeOverrides ...

Mocking IO is required for writeLocalPackageList,
as we want to test the 'add-path' behavior.
While it is not a big concern for overrides, as they
are deprecated and we are unlikely to add new tests,
it is easy to do, and already done for reading them.

Remove the need to mock PackageManager.refresh() ...

We can finally test the full features of the base function,
as we are now mocking the IO, not the logic.

PackageManager: Mock readText, do not mock load ...

This allows us to test the behavior of the base class much better,
by overriding the last IO function, readText.

Move Package.findPackageFile to PackageManager, mock ...

Moving it to PackageManager allows us to call PackageManager.existsFile,
allowing us to mock a lot more things.

Remove the need for intermediate `.zip` file in PackageSupplier ...

By using a different overload of `retryDownload`,
we return the data instead of writing to disk,
ensuring that we don't have a lingering file
in memory and reducing IO.

This follow the same approach for deprecations as previous
`PackageSupplier` deprecations: it's an inevitable, but
easily fixable, breaking change for classes that implement
`PackageSupplier`, but it's a proper deprecation for client
code, based on the assumption that all the classes implementing
`PackageSupplier` are in Dub.

Test: Directly mock writeFile/existsFile from PackageManager ...

This allows us to reduce the number of functions we override,
as we would like to test writeSelections and refresh directly,
not the copy of them we have.

Introduce FSEntry.removeFile, FSEntry.removeDir, refactor FSEntry.writeFile ...

Add the ability to remove directories and files,
and refactor writeFile to make this kind of function
easier to write.

Allow tests to call customCachePaths ...

This is now possible, as refresh has been mostly implemented.

Tests: Remove FSEntry.this dependency on TestDub ...

The dependency should always be the other way around (TestDub depends on FSEntry),
and this is an easy win to move.

Make FSEntry const and scope correct ...

This way we can use it in functions that are using
const/scope, like loadConfig.
As a minor improvement, the two `lookup` overloads
were moved next to one another.

Test: Move writePackageFile to UFCS, better document ...

This is another step in separating FSEntry from TestDub.

Merge both TestDub constructors ...

Those constructors had different but non-overlapping functionalities.
In the event one wanted to set one of the parameters passed to Dub
constructor but also initialize the FS, one was out of luck.

Tests: FSEntry.writeFile write to wrong directory ...

This was a subtle bug hidden by the fact that 'parent' exists
in the class. It was causing problems when calling 'print',
but luckily didn't affect anything else.

Test registry: Store version separate from Package ...

This will allow us to store full packages (FSEntry) instead of
the processed / already instantiated Package.

Introduce readText and make stripUTF8BOM private

Load dub.selections.json in unittest ...

Allow better testing by loading already resolved dependencies.

Move writing selections file to PackageManager ...

The PackageManager is the main source of IO in Dub,
and having it take responsibility for writing the
selections file reduces the number of special casing
we need to make when doing dependency injection.

Tests: Use TestDub FSEntry constructor for more accurate tests ...

The previous approach added Packages in the PackageManager directly,
completely sidestepping the scanning the PackageManager does,
which is a behavior we absolutely want to test.

By setting up the filesystem before we instantiate our `TestDub` instance,
we can remove a bunch of exceptions / overrides, and get a much closer
behavior to the final product.

Tests: Fix vfs paths on Windows ...

With our versioned path implementation, we have the following issue:

assert(NativePath("/foo").absolute); // Passes
assert(NativePath(NativePath("/foo").toNativeString()).absolute); // Fails

However, instead of fixing the implementation, we provide
a different root for the VFS, which is arguably simpler but
also more correct.

Tests: Fix writeFile implementation with vibe-d ...

This was triggering an assert error with vibe-d path.
The recursion logic was a bit murky, so the function
is now split in 3 different part and better documented.

Tests: Simplify loadSCMPackage implementation ...

Now that we can override the git clone operation and load
from the virtual filesystem, we can remove a lot of the
duplicated logic. This is currently hardcoded to a dub.json,
but future iterations can store an FSEntry representing the
full package.

Tests: Add the ability for TestDub to use an initialized filesystem ...

This way, we can test any kind of crazy conditions found in bug reports,
such as the behavior in the face of non-writeable filesystem.

Tests: Move root FSEntry from PackageManager to TestDub ...

This way we can extend its use to all of TestDub.

Trivial: Make TestDub.ProjectPath a NativePath ...

If unittest code wants to reference it, it will be much more useful as NativePath.

Improve unittest framework to have a virtual FS ...

This gets the unittest framework closer to the actual behavior,
and allows us to mock basic FS operations such as mkdir and writeFile.
Further improvements can be made to support more operations,
and to have package setup done before `TestDub` instantiation.