This intends to be a helper structure similar to
`RustTargetData` which includes helper functions
which are useful for interacting with the rustdoc
fingerprint files among other things.

Sometimes we need to remove the `doc/` directory
(if exists) in order to not mix different versions
of the js/html/css files that Rustc autogenerates and
lack versioning.

Before compiling, we need to make sure that if there
were any previous docs already compiled, they were
compiled with the same Rustc version that we're
currently using. Otherways we must remove the
`doc/` folder and compile again.

This is important because as stated in rust-lang#8461
the .js/.html&.css files that are generated
by Rustc don't have any versioning.
Therefore, we can fall in weird bugs and behaviours
if we mix different compiler versions of these
js/.html&.css files.

Is the user does not have permissions or a folder/file
can't be created or deleted, Cargo will fail and return
an Error indicating the problem.

After refactoring what was done on the latest approach
this time we included the rustdoc versioning logic inside
the `compiler::rustdoc` fn.

- Created `RustDocFingerprint` struct so that is easier to
manage all of the logic & functions related to rustdoc
versioning as well as scaling it in the future if needed.

- Check wether the fingerprint is created with the
correct data after a `rustdoc` execution.
- Check wether the previous docs are removed if the version
used to compile them reported in the fingerprint is different
from the actual one being used by the compiler.

As @ehuss suggested, we should only execute once
the rustdoc fingerprint check per build, not once
per dep.

Therefore the checks have been moved to an earlier stage.

Once `RustDocFingerprint::check_rustdoc_fingerprint()` is
executed it might happen that the `doc/` dir is removed.

This means that when we call `fingerprint.write()` we need
to create the `doc` directory again.

- Instead of `fs` we use the `utils::paths` functions
to interact with the filesystem.
- The doc fingerprint is now stored under `target/` instead
of `target/doc/`.
- The code in `compile` has been reduced to a single function call.

When checking the fingerprint for rustdoc and applying
the corresponding logic, we don't only need to consider
the `target/doc` folder (Host target) but also triple targets.

So now the actual compilation targets are checked during the
rustdoc_fingerprint processing and they're treated as the Host/doc
folder.

We should try to avoid dealing with paths ourseleves. Now the
access/parsing and construction is handled via `Layout`.

We were not filtering the cases where the doc folder
paths did not exist.
Also, we were overrwriting the error when it doesn't
make sense. We now return the first one by folding the
results of the doc_dirs removal resolutions.

Co-authored-by: Eric Huss <eric@huss.org>