feat!: add ability to create plugins without an existing Context (#335)

EIP: https://github.com/extism/proposals/pull/8

This PR makes minor breaking changes to several SDKs, but not to runtime
C API. The threadsafety updates in the Rust SDK are kind of specific to
Rust, I'm not sure if it makes sense to add the locks to all the other
SDKs at this point. For the most part the `Context` and `Plugin` types
in the SDKs should be safe to use protected by a mutex but they aren't
inherently threadsafe. That kind of locking should probably be done by
the user.

- Runtime 
  - improve thread safety
  - reinstantiates less
- fixes a potential resource exhaustion bug from re-instantiating using
the same store too many times
- Rust SDK
  - adds `Send` and `Sync` implementations for `Context`
  - adds test sharing a context between threads
- adds `Plugin::call_map` to call a plugin and handle the output with
the lock held
  - adds testing sharing an `Arc<Mutex<Plugin>>` between threads
- adds `Plugin::create` and `Plugin::create_from_manifest` to create a
plugin without a `Context`
- Python
  - BREAKING
- changes `Plugin` constructor to take `context` as an optional named
argument, to update use `Plugin(data, context=context)` instead
 - Ruby
   - BREAKING
- changes `Plugin` constructor to take `context` as an optional named
argument, to update use `Plugin.new(data, context=context)` instead
 - Go
   - adds `NewPlugin` and `NewPluginFromManifest` functions
 - Node
   - BREAKING
- changes `Plugin` constructor to take `context` as an optional named
argument, to update use `new Plugin(data, wasi, config, host, context)`
instead of `new Plugin(context, data, wasi, functions, config)` (most
people are probably using `context.plugin` instead of the Plugin
constructor anyway)
 - OCaml
   - BREAKING
- changes `Plugin.create` and `Plugin.of_manifest` to take `context` as
an optional named argument, to update `Plugin.create ~context data` and
`Plugin.of_manifest ~context data` instead
- Haskell
  - adds `createPlugin` and `createPluginFromManifest` functions
 - Elixir
- adds `Plugin.new` to make a plugin without going through
`Context.new_plugin`
 - Java
   - adds new `Plugin` constructors without a `Context` argument
- C++
  - BREAKING
- Updates `Plugin` constructor to take an optional context as the last
argument, instead of requiring it to be the first argument
- Use `Plugin(wasm, wasi, functions, ctx)` instead of `Plugin(ctx, wasm,
wasi, functions)`
 - Zig
- Adds `Plugin.create` and `Plugin.createWithManifest` to create plugins
in their own context.

---------

Co-authored-by: zach <zach@dylib.so>
Co-authored-by: Benjamin Eckel <bhelx@simst.im>

python/example.py

@@ -5,11 +5,11 @@ import hashlib
 import pathlib
 
 sys.path.append(".")
-from extism import Context, Function, host_fn, ValType
+from extism import Function, host_fn, ValType, Plugin
 
 
 @host_fn
-def hello_world(plugin, input_, output, context, a_string):
+def hello_world(plugin, input_, output, a_string):
     print("Hello from Python!")
     print(a_string)
     print(input_)
@@ -33,24 +33,20 @@ def main(args):
     )
     wasm = wasm_file_path.read_bytes()
     hash = hashlib.sha256(wasm).hexdigest()
-    config = {"wasm": [{"data": wasm, "hash": hash}], "memory": {"max": 5}}
+    manifest = {"wasm": [{"data": wasm, "hash": hash}], "memory": {"max": 5}}
 
-    # a Context provides a scope for plugins to be managed within. creating multiple contexts
-    # is expected and groups plugins based on source/tenant/lifetime etc.
-    with Context() as context:
-        functions = [
-            Function(
-                "hello_world",
-                [ValType.I64],
-                [ValType.I64],
-                hello_world,
-                context,
-                "Hello again!",
-            )
-        ]
-        plugin = context.plugin(config, wasi=True, functions=functions)
-        # Call `count_vowels`
-        wasm_vowel_count = json.loads(plugin.call("count_vowels", data))
+    functions = [
+        Function(
+            "hello_world",
+            [ValType.I64],
+            [ValType.I64],
+            hello_world,
+            "Hello again!",
+        )
+    ]
+    plugin = Plugin(manifest, wasi=True, functions=functions)
+    # Call `count_vowels`
+    wasm_vowel_count = json.loads(plugin.call("count_vowels", data))
 
     print("Number of vowels:", wasm_vowel_count["count"])