Deletes namespace API (#1018)

Formerly, we introduced `wazero.Namespace` to help avoid module name or import conflicts while still sharing the runtime's compilation cache. Now that we've introduced `CompilationCache` `wazero.Namespace` is no longer necessary. By removing it, we reduce the conceptual load on end users as well internal complexity. Since most users don't use namespace, the change isn't very impactful.

Users who are only trying to avoid module name conflict can generate a name like below instead of using multiple runtimes:

```go
moduleName := fmt.Sprintf("%d", atomic.AddUint64(&m.instanceCounter, 1))
module, err := runtime.InstantiateModule(ctx, compiled, config.WithName(moduleName))
```

For `HostModuleBuilder` users, we no longer take `Namespace` as the last parameter of `Instantiate` method: 

```diff
 	// log to the console.
 	_, err := r.NewHostModuleBuilder("env").
 		NewFunctionBuilder().WithFunc(logString).Export("log").
-		Instantiate(ctx, r)
+		Instantiate(ctx)
 	if err != nil {
 		log.Panicln(err)
 	}
```


The following is an example diff a use of namespace can use to keep compilation cache while also ensuring their modules don't conflict:

```diff

 func useMultipleRuntimes(ctx context.Context, cache) {
-	r := wazero.NewRuntime(ctx)
+	cache := wazero.NewCompilationCache()
 
 	for i := 0; i < N; i++ {
-		// Create a new namespace to instantiate modules into.
-		ns := r.NewNamespace(ctx) // Note: this is closed when the Runtime is
+		r := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfig().WithCompilationCache(cache))
 
 		// Instantiate a new "env" module which exports a stateful function.
 		_, err := r.NewHostModuleBuilder("env").
```

Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>

builder.go

@@ -178,13 +178,11 @@ type HostModuleBuilder interface {
 	// NewFunctionBuilder begins the definition of a host function.
 	NewFunctionBuilder() HostFunctionBuilder
 
-	// Compile returns a CompiledModule that can instantiated in any namespace (Namespace).
-	//
-	// Note: Closing the Namespace has the same effect as closing the result.
+	// Compile returns a CompiledModule that can be instantiated by Runtime.
 	Compile(context.Context) (CompiledModule, error)
 
-	// Instantiate is a convenience that calls Compile, then Namespace.InstantiateModule.
-	// This can fail for reasons documented on Namespace.InstantiateModule.
+	// Instantiate is a convenience that calls Compile, then Runtime.InstantiateModule.
+	// This can fail for reasons documented on Runtime.InstantiateModule.
 	//
 	// Here's an example:
 	//
@@ -197,14 +195,14 @@ type HostModuleBuilder interface {
 	//	}
 	//	env, _ := r.NewHostModuleBuilder("env").
 	//		NewFunctionBuilder().WithFunc(hello).Export("hello").
-	//		Instantiate(ctx, r)
+	//		Instantiate(ctx)
 	//
 	// # Notes
 	//
-	//   - Closing the Namespace has the same effect as closing the result.
+	//   - Closing the Runtime has the same effect as closing the result.
 	//   - Fields in the builder are copied during instantiation: Later changes do not affect the instantiated result.
 	//   - To avoid using configuration defaults, use Compile instead.
-	Instantiate(context.Context, Namespace) (api.Module, error)
+	Instantiate(context.Context) (api.Module, error)
 }
 
 // hostModuleBuilder implements HostModuleBuilder
@@ -334,11 +332,11 @@ func (b *hostModuleBuilder) Compile(ctx context.Context) (CompiledModule, error)
 }
 
 // Instantiate implements HostModuleBuilder.Instantiate
-func (b *hostModuleBuilder) Instantiate(ctx context.Context, ns Namespace) (api.Module, error) {
+func (b *hostModuleBuilder) Instantiate(ctx context.Context) (api.Module, error) {
 	if compiled, err := b.Compile(ctx); err != nil {
 		return nil, err
 	} else {
 		compiled.(*compiledModule).closeWithModule = true
-		return ns.InstantiateModule(ctx, compiled, NewModuleConfig())
+		return b.r.InstantiateModule(ctx, compiled, NewModuleConfig())
 	}
 }