Use uint32 instead of uint (64-bit in Go on s390x) to store the return
value of the TIOCGPTN syscall.  This is to avoid the 32-bit value from
being stored into a 64-bit buffer and get left-shifted by 32 when
dereferencing, turning what should be /dev/pts/1 to /dev/pts/4294967296
on big-endian architectures such as s390x.

Special thanks to the explanation and a similar bug fix provided at
containerd/console#51

It's been a while since io/ioutil has been deprecated.
Go 1.22 was just released, and the go.mod specifies 'go 1.20'.
This should be safe to remove at this point.

The change was largely automated, minus the `t.TempDir()` calls inside
test files, which was done manually.

Otherwise it's not obvious that the "go" commands aren't a built-in feature.

It is not currently possible for a custom testscript command
to change the working directory of that script run.
`TestScript.Exec` runs the command in a subprocess,
so one cannot do `ts.Exec("cd", dir)`.

This change adds a `Chdir` method to `TestScript`
that allows changing the working directory of the script.
The implementation is the same as the "cd" command,
which now relies on `Chdir`.

The availability of this function matches similar functionality in the
[`State.Chdir` method of rsc.io/script][1].
(I ported some tests from rsc.io/script to testscript.)

  [1]: https://pkg.go.dev/rsc.io/script#State.Chdir

This allows sending a termination signal to backgrounded commands.

Fixes #242.

They aren't always HOME and TMPDIR; on GOOS=windows they are different.

Switches CI to run against Go 1.21 and 1.22,
and bumps the minimum required Go version to 1.21.

Dropping 1.20 isn't strictly necessary;
this is just matching prior upgrades.
It can be added back if the maintainers prefer.

We had been using ancient versions of golang.org/x modules,
which passed the tests but wasn't great as they contain bugs
and most users would want their newer versions anyway.

Assume Go 1.21 later; use slices.Compact and simplify a test.

While here, update the setup-go action as well.

The call to `T.Failed` and its associated comment are a
legacy of previous implementation. The comment isn't accurate and the
call isn't necessary (`FailNow` is always called even when `ContinueOnError`
is set). Deprecate the associated `TFailed` type rather than removing it.

This makes it possible to pass an arbitrary set of testscript
files to be run instead of just a directory, making it possible
for the testscript command to pass its command line arguments
directly.

In order to check that all the files are actually tested, we need
to make the test harness implement independent subtest failure,
and it's useful to see the name of the test too so that we
can see the name disambiguation logic at work, which
makes for changes to some of the other tests too.

Note that the name deduping logic is somewhat improved from
similar logic in cmd/testscript, in that it is always guaranteed
to produce unique names even in the presence of filenames
that look like deduped names.

It's bugged me for a long time that the error messages printed
by the `testscript` command do not refer to the actual files
passed to the command, but instead to a temporary
file created for the purposes of the command.

This change alters the testscript command so that it
avoids creating an extra copy of the script file, instead
using the new ability of the testscript package to interpret
explicitly provided files instead.

Gratifyingly, this also simplifies the logic quite a bit.

Note: this is dependent on #258, so should not be reviewed
until that lands.

https://github.com/codespell-project/codespell

When an entire script runs and the end is reached, any background
processes begun with a '&' command get interrupted or killed,
depending on the platform and timeout, and we wait for them to finish.

We also checked their resulting status code and failed if they didn't
exit with a status code of 0. However, as explained in the comment,
this would always fail on Windows, given that it doesn't have interrupt
signals so we would kill directly, causing a "signal: killed" error.

Worse, any failures here caused a `panic: fail now!` as that is how
we bubble up errors when a script command is being run, but such panics
were not being recovered once we reached the end of a script.
Now that we don't check the result anymore here, the panics are gone.

Fixes #228.
Fixes #260.

I found that cmd/cue's tests were chatty because goproxytest
was complaining about missing modules which did not matter.
Because those logs always went directly to os.Stderr, I couldn't fix it
without changing the API in this package.

Rather than adding a complex API that takes a logger,
since nearly all downstream use cases come from Go tests,
add an API on top of testing.TB which makes its use much nicer.

It seems like x/mod/sumdb/dirhash appeared way back in 2019,
and we had not noticed until now.

cmp.Or and no longer needing to shallow copy range loop vars.

While here, remove an unused parameter as spotted by gopls.

dirhash, modfile, module, and semver simply forward to the upstream
packages now, so we should no longer advertise them to users.

txtar is very close to that state, but not quite. Add a note.