This fixes a known issue with errno handling.
When calling native functions that set errno (i.e. most of the POSIX functions), we read the errno value after the downcall returned. However, at that time, errno may already have been clobbered by, e.g., the GC.

Therefore, Java's FFM API provides a mechanism to capture the value of errno before actually returning to Java (i.e. before the thread-state transition).

In this PR, I'm adding support for that. I've extended annotation @DowncallSignature such that one can specify if the call state should be captured. The captured state will be stored in a thread-local variable in NativeContext.
With NativeContext.getErrno() and NativeContext.getLastError(), one can access those values.

However, I also had a look at the hosted compiler graphs of the NativePosixSupport.PosixNativeFunctionInvoker.call_* methods and it turns out that those look not very good.
Further, FFM API call state capturing is unconditional but in case of a POSIX function returned w/o an error, errno does not need to be captured.
Since POSIX performance is crucial, I decided to do a custom solution for it.
Hence, in NativePosixSupport, we allocate a thread-local buffer where we store the captured errno value. The pointer to the buffer is passed as argument (name errno_out) to each call_* function. Our POSIX function wrappers then capture the value but only if needed (usually in the error case indicated by the return value). That should be even better than what we did before because we save additional downcalls to read errno.