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.

Beginne damit, die alten und neuesten wit-bindgen-go-Resource-Export-APIs mithilfe des WIT-Counter-Beispiels und der generierten resourceexampleapi.Exports.Counter-Handler zu vergleichen. Ermittle, ob cm.Rep und die manuelle counters-Map vorgesehen sind, und dokumentiere oder formuliere das erwartete Verhalten des Resource-Lebenszyklus und validiere es mit einem geeigneten Binding-Generation-Test, falls ein solcher existiert.

Vom Indexierungsmodell aus dem Issue-Text verfasst.