Implement ObjectStore and ObjectStoreEntry classes for interacting with Fastly ObjectStore

The interfaces for these new classes is as follows:
```
declare class ObjectStore {
    constructor(name: string);
    lookup(key: string): Promise<ObjectStoreEntry | null>;
    put(key: string, value: BodyInit): Promise<undefined>;
}

declare class ObjectStoreEntry {
  get body(): ReadableStream;
  get bodyUsed(): boolean;
  text(): Promise<string>;
  json(): Promise<object>;
  arrayBuffer(): Promise<ArrayBuffer>;
  // And eventually formData and blob once we support them on Request and Response, too.
}
```

ObjectStore is a class we expose to application code for interacting with Fastly ObjectStores and ObjectStoreEntry is not exposed to application code. ObjectStoreEntry is only used as the return result from ObjectStore.lookup for successful lookups.

ObjectStoreEntry has an interface very similar to Response, which is intentional as this is an interface JavaScript developers are familar with and it also can be used as a stream via ObjectStoreEntry.body(), which is useful for applications which want to improve their performance and reduce meory usage.

Below is an example js application which uses the new feature:
```js
addEventListener("fetch", event => {
    event.respondWith(app(event))
})

async function app(event) {
    const store = new ObjectStore('example-store')
    await store.put('hello', 'world')
    let hello = await store.lookup('hello')
    let hellotext = await hello.text()
    return new Response(hellotext)
}
```

Author: Jake Champion

.vscode/settings.json

@@ -74,7 +74,12 @@
         "typeinfo": "cpp",
         "unordered_map": "cpp",
         "utility": "cpp",
-        "*.msg": "cpp"
+        "*.idl": "cpp",
+        "*.inc": "cpp",
+        "*.msg": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "unordered_set": "cpp"
     },
     "git.ignoreLimitWarning": true
 }

c-dependencies/js-compute-runtime/builtin.h

@@ -43,8 +43,8 @@
                                                                                                    \
   bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name) {          \
     if (!is_instance(receiver)) {                                                                  \
-      JS_ReportErrorUTF8(cx, "Method %s called on receiver that's not an instance of %s\n",        \
-                         method_name, class_.name);                                                \
+      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_INSTANCE,         \
+                                method_name, class_.name);                                         \
       return false;                                                                                \
     }                                                                                              \
     return true;                                                                                   \
@@ -154,8 +154,8 @@ template <typename Impl> class BuiltinImpl {
 
   static bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name) {
     if (!Impl::is_instance(receiver)) {
-      JS_ReportErrorUTF8(cx, "Method %s called on receiver that's not an instance of %s\n",
-                         method_name, Impl::class_.name);
+      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_INSTANCE,
+                                method_name, Impl::class_.name);
       return false;
     }