build(deps): bump github.com/testcontainers/testcontainers-go

Bumps [github.com/testcontainers/testcontainers-go](https://github.com/testcontainers/testcontainers-go) from 0.40.0 to 0.41.0.
- [Release notes](https://github.com/testcontainers/testcontainers-go/releases)
- [Commits](https://github.com/testcontainers/testcontainers-go/compare/v0.40.0...v0.41.0)

---
updated-dependencies:
- dependency-name: github.com/testcontainers/testcontainers-go
  dependency-version: 0.41.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/github.com/ebitengine/purego/struct_amd64.go

@@ -85,7 +85,7 @@ const (
 	_MEMORY   = 0b1111
 )
 
-func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []interface{}) []interface{} {
+func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
 	if v.Type().Size() == 0 {
 		return keepAlive
 	}
@@ -120,7 +120,7 @@ func postMerger(t reflect.Type) (passInMemory bool) {
 	if t.Size() <= 2*8 {
 		return false
 	}
-	return true // Go does not have an SSE/SEEUP type so this is always true
+	return true // Go does not have an SSE/SSEUP type so this is always true
 }
 
 func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) (ok bool) {
@@ -165,13 +165,14 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp
 				place(f)
 			case reflect.Bool:
 				if f.Bool() {
-					val |= 1
+					val |= 1 << shift
 				}
 				shift += 8
 				class |= _INTEGER
-			case reflect.Pointer:
-				ok = false
-				return
+			case reflect.Pointer, reflect.UnsafePointer:
+				val = uint64(f.Pointer())
+				shift = 64
+				class = _INTEGER
 			case reflect.Int8:
 				val |= uint64(f.Int()&0xFF) << shift
 				shift += 8
@@ -200,7 +201,7 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp
 				val |= f.Uint() << shift
 				shift += 32
 				class |= _INTEGER
-			case reflect.Uint64, reflect.Uint:
+			case reflect.Uint64, reflect.Uint, reflect.Uintptr:
 				val = f.Uint()
 				shift = 64
 				class = _INTEGER
@@ -238,23 +239,48 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp
 }
 
 func placeStack(v reflect.Value, addStack func(uintptr)) {
-	for i := 0; i < v.Type().NumField(); i++ {
-		f := v.Field(i)
-		switch f.Kind() {
-		case reflect.Pointer:
-			addStack(f.Pointer())
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			addStack(uintptr(f.Int()))
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			addStack(uintptr(f.Uint()))
-		case reflect.Float32:
-			addStack(uintptr(math.Float32bits(float32(f.Float()))))
-		case reflect.Float64:
-			addStack(uintptr(math.Float64bits(f.Float())))
-		case reflect.Struct:
-			placeStack(f, addStack)
-		default:
-			panic("purego: unsupported kind " + f.Kind().String())
-		}
+	// Copy the struct as a contiguous block of memory in eightbyte (8-byte)
+	// chunks. The x86-64 ABI requires structs passed on the stack to be
+	// laid out exactly as in memory, including padding and field packing
+	// within eightbytes. Decomposing field-by-field would place each field
+	// as a separate stack slot, breaking structs with mixed-type fields
+	// that share an eightbyte (e.g. int32 + float32).
+	if !v.CanAddr() {
+		tmp := reflect.New(v.Type()).Elem()
+		tmp.Set(v)
+		v = tmp
+	}
+	ptr := v.Addr().UnsafePointer()
+	size := v.Type().Size()
+	for off := uintptr(0); off < size; off += 8 {
+		chunk := *(*uintptr)(unsafe.Add(ptr, off))
+		addStack(chunk)
 	}
 }
+
+func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
+	panic("purego: placeRegisters not implemented on amd64")
+}
+
+// shouldBundleStackArgs always returns false on non-Darwin platforms
+// since C-style stack argument bundling is only needed on Darwin ARM64.
+func shouldBundleStackArgs(v reflect.Value, numInts, numFloats int) bool {
+	return false
+}
+
+// structFitsInRegisters is not used on amd64.
+func structFitsInRegisters(val reflect.Value, tempNumInts, tempNumFloats int) (bool, int, int) {
+	panic("purego: structFitsInRegisters should not be called on amd64")
+}
+
+// collectStackArgs is not used on amd64.
+func collectStackArgs(args []reflect.Value, startIdx int, numInts, numFloats int,
+	keepAlive []any, addInt, addFloat, addStack func(uintptr),
+	pNumInts, pNumFloats, pNumStack *int) ([]reflect.Value, []any) {
+	panic("purego: collectStackArgs should not be called on amd64")
+}
+
+// bundleStackArgs is not used on amd64.
+func bundleStackArgs(stackArgs []reflect.Value, addStack func(uintptr)) {
+	panic("purego: bundleStackArgs should not be called on amd64")
+}