This commit causes `gccFun` to use `callPackage` with an argument
`gcc_major_version` to indicate which version of gcc is desired.  It
defaults to `default-gcc-version`.

This is stylistic; this code has been inherited from quite a long
time ago, and I never understood what the `1` meant.  Let's just use
`binutilsNoLibc.libc`, which is what `libcCross1` is defined to be,
instead.

This commit causes `gccWithoutTargetLibc` to use `callPackage` with
an argument `gcc_major_version` to indicate which version of gcc is
desired.  It defaults to `default-gcc-version`.

…uild

gccWithoutTargetLibc is useful not only for building cross
compilers, but also for cross-building native compilers.  Let's
allow it to be used in that situation.

This commit simply changes

```
pkg = lowPrio (wrapCC ... )
```

into

```
pkg = ...
```

and wraps the sole occurrence of `pkg` with `lowPrio (wrapCC ... )`.
It has no effect on eval.  I am placing it in a separate commit
simply to make the next commit easier to understand.

This commit checks that libgcc is being built by gcc, and that the
gcc it is being built by is exactly the same version.  Any other
combination of compiler and libgcc is unlikely to work.

Closes #244871

This commit checks for the following situation: we are
cross-building a native compiler (build!=(host==target)) using a
cross-compiler ((build==host)!=target) which is *older than* the
compiler being built.  We check both the cross-compiler itself as
well as the cross-compiler which was used to build the copy of
libgcc against which the target libc is linked.

This configuration often fails (see
#244871 for one example).

If you need to cross-build a newer-than-default-gcc-version native
compiler, you must first build a newer-than-default-gcc-version
cross-compiler.  Previously, the user had to figure out how to hack
in this upgrade on their own.  The code added by this commit inserts
the extra compiler build automatically.