Lua : Multiple returns and Boot.unpack

Lua methods can have "multiple returns".  That is, you can assign to two
or more variables from one method call.

```lua
local x,y = foo()
```

Haxe doesn't support this sort of assignment, so this style won't be
provided in the Haxe syntax.  However, it is important to be able to support
retrieving these additional returns internally.  The best
way of doing this seems to be to wrap the multiple returns in a table
where necessary, and operate on that after the method has returned.

Lua also has an "additional argument" operator that is defined as an ellipsis
(...).  If used as a function argument, you can access the additonal variables
through a special variable called "arg", or by just using the ellipsis in the
function body.

Haxe supports variable argument functions, but not in the same way.
Since I can't use Haxe syntax in either case,  I've just added a helper method
via __lua__.  The method specifies the ellipsis as its argument, and
then wraps this argument in a table as a return.

```lua
pack = function(..){
    return {...}
}
```

So, for any method that returns multiple arguments, I can wrap the
method call in that, and then access any of them in the resulting table.

```lua
local tbl = pack(foo())
```

Now, I can access all the values in a table, as a single return.  Once
again, this isn't something that will be useful externally, but it will
be useful for wrapping existing lua code, and then reconfiguring the
output in a more haxe-like way.

genlua.ml

@@ -1305,6 +1305,10 @@ let generate com =
 
 	List.iter (generate_type_forward ctx) com.types;
 	newline ctx;
+
+	(* add the unpack function. *)
+	spr ctx "lua.Boot.unpack = function(...) return arg end"; newline ctx;
+
 	List.iter (generate_type ctx) com.types;
 	let rec chk_features e =
 		if is_dynamic_iterator ctx e then add_feature ctx "use.$iterator";