Speed up lambda capture handling

[aaronp64]

Updated GDScriptLambdaCallable::call and GDScriptLambdaSelfCallable::call to use alloca instead of Vector when using captures, to avoid extra allocation/copy_on_write calls on each lambda function call.

This makes functions like Array.map and Array.filter around 60% faster when using simple lambda functions with captures, compared with gdscript below:

func _ready() -> void:
	time("test_no_capture")
	time("test_map_multiply")
	time("test_filter")
	time("test_self_lambda")

func test_no_capture():
	var a := range(1000)
	for i in 1000:
		a.map(func(n): return n * 2)

func test_map_multiply():
	var a := range(1000)
	var multiplier := 5
	for i in 1000:
		a.map(func(n): return n * multiplier)

func test_filter():
	var a := range(1000)
	var min := 500
	for i in 1000:
		a.filter(func(n): return n >= min)

var max := 750
func test_self_lambda():
	var a := range(1000)
	var min := 500
	for i in 1000:
		a.filter(func(n): return n >= min && n <= max)

func time(test_name : String):
	var start := Time.get_ticks_msec()
	call(test_name)
	var end := Time.get_ticks_msec()
	print("%s: %dms" % [test_name, end - start])

Old:

test_no_capture: 111ms
test_map_multiply: 212ms
test_filter: 215ms
test_self_lambda: 265ms

New:

test_no_capture: 111ms
test_map_multiply: 129ms
test_filter: 131ms
test_self_lambda: 180ms

Using alloca does require additional stack space, which has a small impact on how many recursive calls can be made when p_argcount + captures_amount is large. The first example below (5 captures + 22 arguments) crashes for me at 567 recursive calls with the new code, and at 574 with old code. The second example (1 capture + 4 arguments) crashes at 606 recursive calls in both versions. I think the difference is small enough to be ok, but I can look into avoiding alloca for larger sizes if needed.

func test_recursive_call_large():
	var c1 := 1
	var c2 := 1
	var c3 := 1
	var c4 := 1
	var c5 := 1
	var recursive_func := func(x, f, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20):
		if x > 0:
			print(c1 + c2 + c3 + c4 + c5)
			f.call(x-1, f, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20)
	
	# 566 max new, 573 old
	recursive_func.call(573, recursive_func, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
	
func test_recursive_call_small():
	var c1 := 1
	var recursive_func := func(x, f, p1, p2):
		if x > 0:
			print(c1)
			f.call(x-1, f, p1, p2)
	
	recursive_func.call(605, recursive_func, 1, 2) # 605 max both

[dalexeev]

Looks good to me.

[akien-mga]

Thanks!