WIP functions working, untested, memory issues, read more

I've ripped out the deep copying, and flattened the bucket usage, but
this results in no memory being freed or reused for the lifetime of the
program.

This is shown most clearly with this script:

```toy
fn makeCounter() {
	var counter: int = 0;

	fn increment() {
		return ++counter;
	}

	return increment;
}

var tally = makeCounter();

while (true) {
	var result = tally();

	if (result >= 10_000_000) {
		break;
	}
}
```

The number of calls vs amount of memory consumed is:

```
function calls -> memory used in megabytes
1_000 -> 0.138128
10_000 -> 2.235536
100_000 -> 21.7021
1_000_000 -> 216.1712
10_000_000 -> 1520.823
```

Obviously this needs to be fixed, as ballooning to gigabytes of memory
in only a moment isn't practical. That will be the next task - to find
some way to free memory that isn't needed anymore.

See #163, #160

source/toy_value.c

@@ -104,43 +104,13 @@ Toy_Value Toy_copyValue(Toy_Value value) {
 			return TOY_VALUE_FROM_STRING(Toy_copyString(value.as.string));
 		}
 
-		case TOY_VALUE_ARRAY:
-		case TOY_VALUE_TABLE:
-		case TOY_VALUE_FUNCTION:
-		case TOY_VALUE_OPAQUE:
-		case TOY_VALUE_ANY:
-		case TOY_VALUE_REFERENCE:
-		case TOY_VALUE_UNKNOWN:
-			fprintf(stderr, TOY_CC_ERROR "ERROR: Can't copy an unknown value type, exiting\n" TOY_CC_RESET);
-			exit(-1);
-	}
-
-	//dummy return
-	return TOY_VALUE_FROM_NULL();
-}
-
-Toy_Value Toy_private_deepCopyValue(Toy_Bucket** scopeBucketHandle, Toy_Bucket** literalBucketHandle, Toy_Value value) {
-	//this should be the same as Toy_copyValue(), but it forces a deep copy for the strings
-	MAYBE_UNWRAP(value);
-
-	switch(value.type) {
-		case TOY_VALUE_NULL:
-		case TOY_VALUE_BOOLEAN:
-		case TOY_VALUE_INTEGER:
-		case TOY_VALUE_FLOAT:
-			return value;
-
-		case TOY_VALUE_STRING: {
-			return TOY_VALUE_FROM_STRING(Toy_deepCopyString(literalBucketHandle, value.as.string));
-		}
-
 		case TOY_VALUE_ARRAY: {
 			//arrays probably won't get copied much
 			Toy_Array* ptr = value.as.array;
 			Toy_Array* result = Toy_resizeArray(NULL, ptr->capacity);
 
 			for (unsigned int i = 0; i < ptr->count; i++) {
-				result->data[i] = Toy_private_deepCopyValue(scopeBucketHandle, literalBucketHandle, ptr->data[i]);
+				result->data[i] = Toy_copyValue(ptr->data[i]);
 			}
 
 			result->capacity = ptr->capacity;
@@ -156,8 +126,8 @@ Toy_Value Toy_private_deepCopyValue(Toy_Bucket** scopeBucketHandle, Toy_Bucket**
 
 			for (unsigned int i = 0; i < ptr->capacity; i++) {
 				if (TOY_VALUE_IS_NULL(ptr->data[i].key) != true) {
-					result->data[i].key = Toy_private_deepCopyValue(scopeBucketHandle, literalBucketHandle, ptr->data[i].key);
-					result->data[i].value = Toy_private_deepCopyValue(scopeBucketHandle, literalBucketHandle, ptr->data[i].value);
+					result->data[i].key = Toy_copyValue(ptr->data[i].key);
+					result->data[i].value = Toy_copyValue(ptr->data[i].value);
 				}
 			}
 
@@ -166,35 +136,15 @@ Toy_Value Toy_private_deepCopyValue(Toy_Bucket** scopeBucketHandle, Toy_Bucket**
 
 			return TOY_VALUE_FROM_TABLE(result);
 		}
-		case TOY_VALUE_FUNCTION: {
-			if (TOY_VALUE_AS_FUNCTION(value)->type == TOY_FUNCTION_MODULE) {
-				Toy_Function* fn = Toy_createModuleFunction(literalBucketHandle, TOY_VALUE_AS_FUNCTION(value)->module.module);
 
-				//BUGFIX: rewire any and all strings within the function's ancestors
-				if (fn->module.module.parentScope != NULL && fn->module.module.parentScope->next != NULL) {
-
-					//break the loop to prevent infinite loops...???
-					//URGENT: fuck
-					Toy_Scope* tmp = fn->module.module.parentScope;
-					fn->module.module.parentScope = NULL;
-
-					Toy_Scope* duplicate = Toy_private_deepCopyScope(scopeBucketHandle, literalBucketHandle, tmp->next);
-					fn->module.module.parentScope = Toy_private_pushDummyScope(scopeBucketHandle, duplicate); //insert a new dummy
-				}
-
-				return TOY_VALUE_FROM_FUNCTION(fn);
-			}
-
-			fprintf(stderr, TOY_CC_ERROR "ERROR: Can't deep-copy an unknown function type value, exiting\n" TOY_CC_RESET);
-			exit(-1);
-			break;
-		}
+		case TOY_VALUE_FUNCTION:
+			return value; //URGENT: concerning
 
 		case TOY_VALUE_OPAQUE:
 		case TOY_VALUE_ANY:
 		case TOY_VALUE_REFERENCE:
 		case TOY_VALUE_UNKNOWN:
-			fprintf(stderr, TOY_CC_ERROR "ERROR: Can't deep-copy an unknown value type, exiting\n" TOY_CC_RESET);
+			fprintf(stderr, TOY_CC_ERROR "ERROR: Can't copy an unknown value type, exiting\n" TOY_CC_RESET);
 			exit(-1);
 	}