feat(go-runtime): add helper functions for the new interface type (#4936)

### Description
Some of our L1 resources will start to take array of interfaces(`*[]interface{}`) instead of (`*[]*string`) as props same applies for Numbers. This PR creating multiple helper functions that can help to make customer life easier.

### L1 Example
[CfnUserProps](https://pkg.go.dev/github.com/aws/aws-cdk-go/awscdk/v2/awsiam#CfnUserProps) has now
```
ManagedPolicyArns *[]*[string](https://pkg.go.dev/builtin#string) `field:"optional" json:"managedPolicyArns" yaml:"managedPolicyArns"`
```
will change to 
```
ManagedPolicyArns *[]interface{}`field:"optional" json:"managedPolicyArns" yaml:"managedPolicyArns"`
```
### Helper Functions Usage Example
#### Use Case 1
If you before was using `jsii.Strings()` or `jsii.Numbers()`
```
&CfnUserProps{
  ManagedPolicyArns: jsii.Strings("arn1", "arn2"),
}
```
Rename function to use `jsii.AnyStrings()` like this
```
&CfnUserProps{
  ManagedPolicyArns: jsii.AnyStrings("arn1", "arn2"),
}
```
#### Use Case 2
If you manually were creating the strings using without `jsii.Strings` syntax
```
func Arns() *[]*string {
	a := "arn:aws:s3:::bucket1"
	b := "arn:aws:s3:::bucket2"
	return &[]*string{&a, &b}
}

&CfnUserProps{
  ManagedPolicyArns: Arns(),
}
```
Wrap it with `jsii.AnySlice()` like this
```
&CfnUserProps{
  ManagedPolicyArns: jsii.AnySlice(Arns()),
}
```
---

By submitting this pull request, I confirm that my contribution is made under the terms of the [Apache 2.0 license].

[Apache 2.0 license]: https://www.apache.org/licenses/LICENSE-2.0

Author: gasolima

packages/@jsii/go-runtime/jsii-runtime-go/helpers.go

@@ -72,3 +72,35 @@ func Time(v time.Time) *time.Time { return Ptr(v) }
 func Times(v ...time.Time) *[]*time.Time {
 	return PtrSlice(v...)
 }
+
+// AnyStrings returns a pointer to a slice of any containing all the provided strings.
+func AnyStrings(v ...string) *[]interface{} {
+	slice := make([]interface{}, len(v))
+	for i := 0; i < len(v); i++ {
+		slice[i] = v[i]
+	}
+	return &slice
+}
+
+// AnyNumbers returns a pointer to a slice of any containing all the provided numbers.
+func AnyNumbers[T numberType](v ...T) *[]interface{} {
+	slice := make([]interface{}, len(v))
+	for i := 0; i < len(v); i++ {
+		slice[i] = float64(v[i])
+	}
+	return &slice
+}
+
+// AnySlice converts a pointer to a slice of pointers to a pointer to a slice of Any.
+func AnySlice[T any](v *[]*T) *[]interface{} {
+	if v == nil {
+		return nil
+	}
+	slice := make([]interface{}, len(*v))
+	for i, ptr := range *v {
+		if ptr != nil {
+			slice[i] = *ptr
+		}
+	}
+	return &slice
+}

packages/@jsii/go-runtime/jsii-runtime-go/helpers_test.go

@@ -25,6 +25,12 @@ func TestV(t *testing.T) {
 	assert.Equal(t, now, *Time(now))
 	// Times
 	assert.Equal(t, []*time.Time{Time(now)}, *Times(now))
+	// AnyStrings
+	assert.Equal(t, []interface{}{"Hello", "World"}, *AnyStrings("Hello", "World"))
+	// AnyNumbers
+	assert.Equal(t, []interface{}{float64(42), float64(1337)}, *AnyNumbers(42, 1337))
+	// AnySlice
+	assert.Equal(t, []interface{}{"hello", "world"}, *AnySlice(Strings("hello", "world")))
 }
 
 func TestBool(t *testing.T) {
@@ -81,3 +87,34 @@ func TestTimes(t *testing.T) {
 	now := time.Now()
 	assert.Equal(t, []*time.Time{Time(now)}, *Times(now))
 }
+
+func TestAnyStrings(t *testing.T) {
+	assert.Equal(t, []interface{}{"Hello", "World"}, *AnyStrings("Hello", "World"))
+}
+
+func TestAnyNumbers(t *testing.T) {
+	assert.Equal(t, []interface{}{float64(42), float64(1337)}, *AnyNumbers(42, 1337))
+}
+
+func TestAnySlice(t *testing.T) {
+	// Test with *[]*string
+	strings := []*string{String("hello"), String("world")}
+	result := AnySlice(&strings)
+	assert.Equal(t, []interface{}{"hello", "world"}, *result)
+
+	// Test with strings
+	result2 := AnySlice(Strings("hello", "world"))
+	assert.Equal(t, []interface{}{"hello", "world"}, *result2)
+	
+	// Test with *[]*float64
+	floats := []*float64{Number(1.5), Number(2.5)}
+	result3 := AnySlice(&floats)
+	assert.Equal(t, []interface{}{1.5, 2.5}, *result3)
+
+	// Test with Numbers
+	result4 := AnySlice(Numbers(1.5, 2.5))
+	assert.Equal(t, []interface{}{1.5, 2.5}, *result4)
+	
+	// Test with nil
+	assert.Nil(t, AnySlice((*[]*string)(nil)))
+}