Allow returning promises from StorageManager `.load` and `.store` methods

This would offer a more modern and clean API than the current callback based approach.

Proposed API:

editor.StorageManager.add('simple-storage', {
  load: async keys => {
    const result = await foo(keys)
    return JSON.parse(result)
  },
  async store(data) {
	const result = await bar(data)
    return result
  }
});

There are a few ways this could be implemented:

1. Detect if the load/save method is thenable, if so await

This would complicate the API and code a little as users would need to make a choice between using either the callback or Promise based approach. The upside to this though is that it would not be a breaking change.

A side effect of this API change would allow mixing and matching of approaches:

// An async load method and callback store method
editor.StorageManager.add('simple-storage', {
  load: async keys => {
    const result = await foo(keys)
    return JSON.parse(result)
  },
  store(data, clb, clbErr) {
	bar(data, err => {
      if (err) return clbErr(err)
      clb()
    })
  }
});

2. Switch to a Promise only StorageManager API

The big benefit of this is we would be encouraging a more best practice approach and the API would be far less complicated. Not having to support two slightly different APIs is also good for maintenance. Unfortunately it would be a breaking change and might be best paired with a Promise rollout across the whole library. There are other APIs that could do with supporting promises too, commands for example.

3. Add new methods asyncLoad and asyncStore

The user would need to choose to either use the callback-based load/store methods, or their promise-based async counterparts. To me, this seems like the worst of options 1 & 2.

I'd be happy to open a PR for this, but would be good to get thoughts on which approach is best before continuing :smile: