Create anonymous objects as dynamically created classes.

Turn anonymous objects into instances of a dynamically created class. References to local variables outside the anonymous object
block (uprefs) are turned into instance variables in the new class and initialized from the current value. This is the model that List
uses to create its iterator.

Reference to these upref variables are now generated as messages instead of dot references.

Limitations of this approach are that methods are static and can't be rewritten, references to other fields in the anonymous object
aren't handled and the current code can't handle nested anonymous objects.

The main goal of this is to get iterator working for List.
Method in Array take an int for index instead of the object that NSMutableArray uses.

It's not clear that saving/restoring require_pointer is necessary.
Escape chars when writing a string literal.
 A setter name must end with ":"

Looks like that happens when the method is created but the @property definition didn't have it.
Add import for a property so the include will be generated in the header.
Use underlying class when adding an abstract import since we don't actually generate headers for abstract classes.

Maybe this is/should be handled by importing the module?
Use underlying class for the type name of an abstract since we don't generate anything for an abstract class so it's name isn't of much use.
Consider more types when checking for a String.

Should probably handle even more types/constructs.
If something is turned into a category we need to use the base class that the category was applied to find the type name.
A bunch of debugging output so I can figure out what's going on.
Objective-C cares about the names of parameters since the name is used to create "selectors" so make everything match.
Fix method selector generation for anonymous object methods.
Keep track of variables (as opposed to functions) when generating an anonymous object so we can later initialize them.

TODO: The actual initialization after the block/anonymous object is instantiated.
Handle assignment specially so we can generate it with Objective-C messaging using a "setter".

This lets us work with variables in anonymous objects.
Generate instance variables for "variables" decelerated as part of anonymous objects so we can access them with getter/setters.
Initialize static to nil if there isn't an expression.

TODO: Proper default value initialization but at least is compiles now when nil is a valid value.
Create complete "message" access for fields in generateValue so they can be nested with other message passing generation by making it self-contained.
Don't wrap generated expression in brackets ([]) in generateExpression. We now do that in generate value and callers should do it when appropriate.

The generating_calls stuff seems to be becoming obsolete since we're now using messaging getters/setters or set/getKeyValue
Use generateExpression here since generateValue now generates more complete messaging constructs (with []).

Part of the move to use messaging instead of dot notation since dot notation is problematical with anonymous objects.
Support @:functionCode so we can include arbitrary Objective-C code -- just like some of the other backends.