While going through the migrations, I noticed that this was still marked
as async even though nothing is async about this. Simplified it to a
simple sync function instead.

This is likely temporary, but needed to know which migrations were sync
or async, and which migrations are an _actual_ migration from v3 → v4 or
which ones are mere optimizations in v4 land.

The v4 optimizations will be moved to the `canonicalizeCandidates` logic
straight on the design system.

+ initial basic implementation

After all migrations happened, we run the canonicalization step to
perform the last bit of migrations

We will likely clean this up later. But just trying to move things
aroudn first.

If you use `canonicalizeCandidates(['bg-red-500', 'bg-red-500/100'])`
they would both canonicalize to `bg-red-500`. No need to return
duplicates here.

Note: this commit on its own _will_ have some failing tests because the
`migrate-arbitrary-utilities.test.ts` file combined some other
migrations as well.

Eventually once those are ported over, will make the tests pass.

Another thing to notice is that we updated some tests. The more we
canonicalize candidates, the more tests will need upgrading to an even
more canonical form.

This test setup already tests various cases including prefixes and
important strategies.

We were also converting the current charcode back to a string, but we
already had that information in `input[i]`

The part where we upgrade old v3 syntax like `group-[]:` still exists in
the `@tailwindcss/upgrade` package.

We were relying on `postcss-selector-parser`, but the copied part is now
using our own `SelectorParser`.

I also added a temporary attribute selector parser to make everything
pass. Don't look at the code for that _too_ much because we will swap it
out in a later commit 😅

A bunch of migrations were moved to `canonicalizeCandidates`, so we
still have to run that at the end.

Also used:
```css
@theme {
  --*: initial;
}
```

To make the design system a bit faster.

Note: we made sure that all the tests passed before this commit, and we
also made sure to not touch any of the tests as part of this commit
ensuring that everything still works as expected. Aka, an actual
refactor without behavior change.

This is a big commit and a big refactor but that's mainly because there
are some re-indents that are happening. Will maybe split up this commit
but then it won't be an atomic (working) commit anymore.

One thing I noticed is that all our "migrations" essentially parsed a
raw candidate, did some work and then stringified the candidate AST
again.

That's one of the reasons I inlined the migrations in previous commits
in a single file. Looking at the file now, it's a little bit silly that
we parse and print over and over again.

Parsing a raw candidate also results in an an array of `Candidate` AST
nodes, so we always had a loop going on.

Another thing I noticed is that often we need to work with a "base"
candidate, that's essentially the candidate without the variants and
without the important flag.

That's where this refactor comes in:

1. We parse each candidate _once_
2. When there are variants, we canonicalize each variant separately and
   store the results in a separate cache.
3. When there are variants _or_ the important flag is present, we
   canonicalize the base utility separately and later re-attach the
   variants and important flag at the end. This means that not a single
   canonicalization step has to deal with variants or important flag.
4. Since we only want to parse the candidate once on the outside, we
   will pass a cloned `Candidate` to each canonicalize step to prevent
   parsing and printing over and over again.
5. Only at the end will we re-print the `Candidate`

This process has a few benefits:

1. We are handling candidates and variants separately and caching them
   separately. This means that we can increase cache hits because
   variants from candidate A and candidate B can be re-used. E.g.:
   `[@media_print]:flex` and `[@media_print]:underline` will map to
   `print:flex` and `print:underline` where `[@media_print]` is only
   handled once.
2. This also means that we could simplify some canonicalization steps
   because they don't have to worry about variants and the important
   flag.
3. There is no parsing & looping over the parsed candidates array going
   on.

The the scenario of creating signatures for a component, we always want
to respect the important flag if it is given. Therefore I think that we
can drop the `designSystem.compileAstNodes(candidate,
CompileAstFlags.None)` which saves us some time.

Also removed the `structuredClone` call. Whenever we handle `@apply`
which essentially happened the step before, we already start from a
cloned node internally. This call just meant we were doing it again.

This implementation is also 2-3x faster than the original one.

```
AttributeSelectorParser.parse - src/attribute-selector-parser.bench.ts > parsing
  2.24x faster than REGEX.test(…)
  2.59x faster than ….match(REGEX)
  2.84x faster than parseAttributeSelector
```