Allow unrolling loops over arrays of known size

[SaculRennorb]

Sometimes it is very useful to be able to unroll a loop over a array, specifically to express bit manipulation over some wider buffer of things.

Currently there are two separate restrictions that make this not possible:

fn1 :: proc(d : [4]u32)
{
	acc := u32(0)
	d := d
	// Ok:
	for &a, i in d {
		a = a & (1 << uint(i))
		acc += a
	}

	// this does not work: 
	#unroll for &a, i in d {
		a = a & (1 << uint(i))
		acc += a
	}
}

The first issue is that the #unroll pragma only works on range based for loops, e.g. loops with a range expression. While the error does not reflect this, the docs say as much.
I suspect this is the reason why the compiler does not like me taking the address of a here either, but this is probably a minor aspect of the whole thing.

The main issue is that

#unroll for a in d {
}

already fails to compile, with the error of An '#unroll for' expression must be known at compile time. This error is misleading, as the expression is known at compile time, and it should be fairly trivial to translate this into

a = d[0]
a = d[1]
a = d[2]
a = d[3]

as the length of the array is known. Additionally it should also be trivial to translate the addressable and value + index versions of the loop in a similar fashion.

In the real world I ran into this while writing some hash functions.

[gingerBill]

So the problem here at the moment is that for &a is not supported, only for a.