kernel: three C fixes

[cyclistmass]

1. The kernel backtrace follows a zero stack word to NULL.
walk_stack_frames advances through the control stack by interpreting a
non-frame word, and two of its arms follow that word as a pointer:

} else if ((header & fixnummask) == 0) {
  next = (lisp_frame *)header;
} else if (header == stack_alloc_marker) {
  next = (lisp_frame *)(current[1]);

Zero satisfies (header & fixnummask) == 0, and a control stack holds many
zero words. next becomes NULL, the loop tail does start = next, the
while (start < end) test passes, and lisp_frame_p(NULL) dereferences
address 0. The kernel backtrace therefore faults while it prints the backtrace
for another fault, and the report that would identify the original defect is
lost. Any small fixnum reaches the same end at a different address, and a
candidate below start walks backwards or spins forever. The test needed is
not "does this word carry a fixnum tag" but "is this a forward address inside the
region under walk".

2. recursive_lock_trylock leaks a recursive count on EBUSY.
In both arms, futex and non-futex, when the calling thread already owns the
lock and was_free is NULL, the owner branch increments m->count and falls
into the store_conditional on m->avail. That store fails, because the
caller already holds the lock. The function then returns EBUSY with the count
already raised, and the caller never releases a lock it believes it never got.

The early return was conditional on was_free being non-NULL, when only the
*was_free store needed that condition. No caller exists in the tree today,
and the kernel-import tables export the function. This is the fix for issue
#597.

3. SUPPORT_PRAGMA_UNUSED is tested in ten places and defined in none.
The patch defines it for clang only.

$ git grep -c SUPPORT_PRAGMA_UNUSED -- 'lisp-kernel/*.c'
lisp-kernel/arm-exceptions.c:3
lisp-kernel/arm64-exceptions.c:3
lisp-kernel/ppc-exceptions.c:4
$ git grep -n 'define[[:space:]]*SUPPORT_PRAGMA_UNUSED'
(nothing)

Most sites mark a parameter that a handler-dispatch signature forces on the
function and the body does not use. The intent is written down, and only the
channel to the compiler is dead.

Measured on the do_hard_stack_overflow shape, with a positive control that
compiles the same source without the pragma and emits unused parameter as
required. clang 15.0.7 accepts the pragma and those warnings go to 0. gcc 11.5.0
does not recognize it, so the warnings survive and -Wunknown-pragmas adds one
diagnostic of its own. That is why the define is clang-only: unconditional, it
would suppress nothing on gcc and add a warning per site.

Two boundaries on that. I compiled the arm64 shape, not all ten sites. And one
site is not an unused parameter at all: handle_uuo in ppc-exceptions.c
declares #pragma unused(where), then passes where to handle_error twice.
That pragma looks simply wrong, and this patch does not change it -- it only
gives the guard a definition on the compiler that implements it.

---

Verified at this base. Built and run on linuxarm64 at ec578745 with all
ten patches applied: ANSI 21679 tests, 0 failures. tests/ccl.lsp 243 tests, 0
failures. Image 281a49e5, kernel 67bb66b4.

[xrme]

The recursive_lock_trylock issue #597 was fixed in b5a00d1