Implementation files (in C) for libpkl as described in SPICE

As a demonstration of how to build a shared library together with our
`native-image` shared library, use the following locally:

```
❯ gradle :libpkl:assembleNative

❯ clang -v -shared \
    -o libpkl.dylib \
    libpkl/src/main/c/libpkl.c \
    -Ilibpkl/src/main/c \
    -Ilibpkl/build/libs/macos-aarch64 \
    -Llibpkl/build/libs/macos-aarch64 \
    -lpkl-macos-aarch64
```

Author: KushalP

libpkl/src/main/c/libpkl.c

@@ -0,0 +1,69 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+
+#include <graal_isolate.h>
+#include <libpkl-macos-aarch64.h>
+
+#include <libpkl.h>
+
+#ifndef NULL
+  #define NULL 0
+#endif
+
+pthread_mutex_t graal_mutex;
+graal_isolatethread_t *isolatethread = NULL;
+
+int pkl_init(PklMessageResponseHandler handler) {
+  if (isolatethread != NULL) {
+    perror("pkl_init: isolatethread is already initialised");
+    return -1;
+  }
+
+  if (pthread_mutex_init(&graal_mutex, NULL) != 0) {
+    perror("pkl_init: couldn't initialise pthread_mutex");
+    return -1;
+  }
+
+  if (pthread_mutex_lock(&graal_mutex) != 0) {
+    return -1;
+  }
+
+  isolatethread = pkl_internal_init();
+  pkl_internal_register_response_handler(isolatethread, handler);
+  pkl_internal_server_start(isolatethread);
+  pthread_mutex_unlock(&graal_mutex);
+
+  return 0;
+};
+
+
+int pkl_send_message(int length, char* message) {
+  if (pthread_mutex_lock(&graal_mutex) != 0) {
+    return -1;
+  }
+
+  pkl_internal_send_message(isolatethread, length, message);
+  pthread_mutex_unlock(&graal_mutex);
+
+  return 0;
+};
+
+int pkl_close() {
+  if (pthread_mutex_lock(&graal_mutex) != 0) {
+    return -1;
+  }
+
+  pkl_internal_server_stop(isolatethread);
+  pkl_internal_close(isolatethread);
+
+  if (pthread_mutex_unlock(&graal_mutex) != 0) {
+    return -1;
+  }
+
+  if (pthread_mutex_destroy(&graal_mutex) != 0) {
+    return -1;
+  }
+
+  return 0;
+};

libpkl/src/main/c/libpkl.h

@@ -0,0 +1,31 @@
+/**
+* @brief The Pkl Message Response Handler that a user should implement.
+*
+* The resulting messages from `pkl_send` will be sent to this
+* handler using a callback style.
+*/
+typedef void (*PklMessageResponseHandler)(int length, char* message);
+
+/**
+* @brief Initialises and allocates a Pkl executor.
+*
+* @return -1 on failure.
+* @return 0 on success.
+*/
+int pkl_init(PklMessageResponseHandler handler);
+
+/**
+* @brief Send a message to Pkl, providing the length and a pointer to the first byte.
+*
+* @return -1 on failure.
+* @return 0 on success.
+*/
+int pkl_send_message(int length, char* message);
+
+/**
+* @brief Cleans up any resources that were created as part of the `pkl_init` process.
+*
+* @return -1 on failure.
+* @return 0 on success.
+*/
+int pkl_close();