Resource export is unclear

Hi!
I'm in the middle of migrating from the old binding generator in `wit-bindgen` to the latest version of `wit-bindgen-go` and got confused by what exactly new way of exporting resources is.

Let's take an example where we define and export a _counter_ resource:

```wit
package resource:example;

interface api {
resource counter {
constructor(name: string);
add: func(value: u64);
get: func() -> u64;
}
}

world example {
export api;
}
```

In the old binding generator to export this, it was possible to write a Go struct with methods on it and a constructor on the exported type:

```go
// struct representing the component
type ResourceExampleImpl struct {
}

// struct representing an instance of the resource
type Counter struct {
name string
current uint64
}

func (e *ResourceExampleImpl) ConstructorCounter(name string) resource_example.ExportsResourceExampleApiCounter {
return &Counter{
name: name,
current: 0,
}
}

func (e *Counter) MethodCounterAdd(value uint64) {
e.current += value
}

func (e *Counter) MethodCounterGet() uint64 {
return e.current
}

func init() {
resource_example.SetExportsResourceExampleApi(&ResourceExampleImpl{})
}
```

With the latest `wit-bindgen-go` the only way I found to do the same is to manually maintain a map of the generated resources indexed by `cm.Rep`:

```go
type Counter struct {
name string
current uint64
}

func NewCounter(name string) *Counter {
return &Counter{
name: name,
current: 0,
}
}

func (e *Counter) Add(value uint64) {
e.current += value
}

func (e *Counter) Get() uint64 {
return e.current
}

var counters = make(map[cm.Rep]*Counter)
var lastId = cm.Rep(0)

func init() {
resourceexampleapi.Exports.Counter.Constructor = func(name string) (result resourceexampleapi.Counter) {
counter := NewCounter(name)
id := lastId + 1
lastId = id
counters[id] = counter
return resourceexampleapi.CounterResourceNew(id)
}

resourceexampleapi.Exports.Counter.Destructor = func(id cm.Rep) {
delete(counters, id)
}

resourceexampleapi.Exports.Counter.Add = func(id cm.Rep, value uint64) {
counters[id].Add(value)
}

resourceexampleapi.Exports.Counter.Get = func(id cm.Rep) uint64 {
return counters[id].Get()
}
}
```

Is this how it is supposed to work or am I missing something?
The new binding generator version is much nicer than the previous one in many ways, but having to manually keep track of resources seems weird to me.