Rework TOC-style 3-tuple detection in `add_datas` and `binaries`;
instead of checking for instance of `TOC` class, check if the
length of the first entry is three.

This will allow us to replace the `TOC` class with regular list.

Instantiate `self.binaries` as a regular list instead of an
instance of the `TOC` class; we do not need any of its functionality
here.

Use the lazy string formatting offered by logger method calls
instead of directly formatting strings using the % syntax.

We are returning a simple list of modules, so there's no need for
TOC class there as we know the list has no duplicates.

There is exactly one call that passes the existing TOC in our
codebase, and even there we can simply append the output to the
existing TOC.

The returned toc is now a list as opposed to instance of the TOC
class. This removes implict deduplication functionality, but
should not be an issue at this step, because entries are generated
from the module graph (and so there should not be any duplicates
here).

Turn `Tree` class into child of regular `list` instead of `TOC`
class, as part of on-going `TOC` class depreciation.

As `Tree` describes the contents of the filesystem, implicit TOC
de-duplication should not be required in the first place.

Also initialize `Target.dependencies` with plain `list`.

For now, the normalization helper function is a stub that internally
uses the TOC class; this allows us to gradually limit/encapsulate
the use of TOC class within the codebase.

Process extensions (rename them to full filenames) immediately
after we obtain the list of extensions from the modulegraph.

Instead of using TOC class, perform explicit TOC list normalization
at certain build stages.

When `Analysis.pure` TOC list was an instance of the `TOC` class,
we could dynamically add an attribute `_code_cache` to it, and use
that to pass the code cache dictionary around. The `PYZ` writer
would then check for the presence of the attribute on the received
arguments and extend its internal code cache accordingly.

Now that the TOC list is a plain `list`, the custom attribute
cannot be added anymore. To work around this, we store new
dictionary in global `CONF['code_cache']`, where we associate
the list's `id()` with its code cache dictionary. This gives us
the same semantics as the old approach.

The CONF override in `test_issue_2492` and `test_issue_5131`
should initialize the newly-introduced `code_cache` dictionary.

The `Splash` target is trying to detect whether user's code already
uses `_tkinter` by looking for extension in the `binaries` TOC.
However, it uses the `filenames` property of the `TOC` class, which
is not available anymore now that the TOC lists have been switched
to plain `list`.

Futhermore, as it is trying to look up `_tkinter` extension by
module name, this means that the detection has been effectively
broken since pyinstaller#7273 where we pushed conversion of extension module
names to full extension filenames into `Analysis`. So the search
in `binaries` needs to be done with full extension filename rather
than module name.

Replace the TOC list normalization stubs with proper implementation
that encodes priority information. This for example ensures that
if a file is collected both as a DATA and BINARY, we always treat
is as BINARY (and hence subject it to additional binary processing).

We now have TOC normalization with priority system in place, so
we can directly extend the EXE's TOC with entries from all passed
targets' dependencies.

And ignore it in the TOC class unit tests.

Update documentation on TOC lists now that the TOC class has
been officially deprecated.

Ensure that TOC is properly de-duplicated even if dest_name
contains loops with parent directory path components. For example,
`numpy/core/../../numpy.libs/libquadmath-2d0c479f.so.0.0.0` and
`numpy/linalg/../../numpy.libs/libquadmath-2d0c479f.so.0.0.0`
should be considered duplicates, as they are both normalized to
`numpy.libs/libquadmath-2d0c479f.so.0.0.0`.

Therefore, we now have the TOC normalization helpers to always
sanitize the `dest_name` using `os.path.normpath` (with `pathlib`
lacking the equivalent functionality), so that the entries are
properly de-duplicated and that destination name is always in
its compact/normalized form.

We should probably also look into path normalization in the
`bindepend.getImports` function, but at the end of the day,
the TOC normalization serves as the last guard against problematic
entries.