* These are defined by C23 and jemalloc actually provides them
  beginning with FreeBSD 16.
  Since glib is using free_sized() when available, builds were broken
  on FreeBSD 16.
* Should be backported to the SciTECO 2.5.2 FreeBSD port to
  silence the fallout.

For yet unknown reasons this does not improve performance on GCC 16
even though it also supports `__attribute__((musttail))`.
As long as I do not understand why, I don't want to risk any
unnecessary problems. I have reason to believe that the tail-call
optimized version still has subtle bugs.

See also the "tail-calls" branch.

This reverts commit 2e097cec409182c3cb39b74489387480bf8a278f.

Now use the teco_spawn_check_wait_status(), which was previously in spawn.c,
so we no longer have to handle the UNIX-specific WEXITSTATUS() macros.

* Simplifies the common task of querying an integer or string from a Q-Register table.
* Undefined Q-Regs are reported as TECO_ERROR_QREGUNDEF, so you can theoretically
  handle this case. In practice however, it requires less boilerplating to
  just call teco_qreg_table_find() manually.
* It also doesn't make sense to use these functions when getting and setting
  a register at the same time as you will want to avoid repeated lookups.

* On newer GCC (>= 15) and Clang (>= 13) versions we can tail call
  at the end of input_cb() implementations to the next state's input_cb(),
  which will be optimized to jumps (often direct jumps).
  That is, the compilers always optimized tail calls, but we can
  guarantee tail calls with the __attribute__((musttail)) statement
  attribute.
* Every `return &teco_state_xxx` has to be replaced with
  `TECO_RETURN(ctx, &teco_state_xxx, error)`.
* This speeds up `-O2 -flto` builds by 18%
  (e.g. tested on grosciteco for sciteco(7)).
  Part of the speed up could also be because of inlining through
  TECO_RETURN().
* The other state machines (stringbuilding and q-reg spec) cannot
  currently be optimized the same way since they get their characters
  passed in from the "main" state machine.
* All loops around callbacks could be optimized the same way.
  E.g. the undo token runner could also tail call into the next runner,
  but it's probably not important to optimize undo token executions.

See also 8a8edaa2daf37f7c12e21b9199755b5de8e489f5.

These can fail, so abort() just like glib does internally in case of OOM.
A special case is the pad allocation for autocompletion popups, which
can have excessively many lines. This is handled gracefully now
(the popup simply won't be displayed).

* It sends `null` instead of empty lists, even though this is violating the LSP specs.
* Filter out duplicates from the auto-completion lists.
  This may benefit other servers as well.
* ctags-lsp does not fuzzy search for workspace/symbol, so auto-completions
  aren't really a thing.
  The only special case is sending the empty string, which results in
  all symbols being returned. This can be slow, though.
* ctags-lsp does not support textDocument/references, so n:FT$ won't be supported.

* We use 23 now as the "id" for all JSON-RPC requests.
* Every message with a different "id" can be ignored,
  as it is a request, we haven't advertised to support.
  Alternatively, we should perhaps send an error response to
  unexpected requests?
* Fixes support for the ccls server which sends window/workDoneProgress/create
  even though I didn't advertise it.
  ccls cannot practically be used with FTsymbol$ though since it returns
  full declarations.
  You can perform a fuzzy symbol search, though.

If you have projects in different languages you can set different LSPs.
The default will still come from ~/.teco_ini if you decide to set one.
The default for $SCITECO_LSP_ROOT is set by session.tes' VCS integration
based on the VCS root, but you could still overwrite it per session.