Fullscreen support

Fullscreen is toggleable with the F12 key (customizable, of course).

I moved the JFrame code to Game, so now it can be changed any time.

Game has a new aspectRatio variable instead of a height variable, and
height is calculated by multiplying width by that. I chose that to make
different screen resolutions easier.
Major Update to Mass and World Systems

World is now considered a complete class instead of being abstract. I
was increasingly using it to do stuff, and it honestly just felt more
solid than its children, so I want ahead and put all the logic in it.
Ideally in the future it will just read saved data anyway.

World never takes the liberty of adding or removing things to itself. It
doesn't even have a generic add() method anymore. They have to add
themselves, which is currently done in their constructors. This creates
a problem if you try to create an entity or whatever from World's
contructor, so I made an init() method that does all that and gets
called by Game after World is created.

Player gravitates now. I added some early throttle code, but it doesn't
do anything substantial yet.
rotation, bitches!

Implemented, because I am a boss. Render now holds both the main
BufferedImage and Graphics2D, and can have methods that access those as
well as pixels, or both at the same time. This makes Render much more
powerful.

Getting ready for some collision detection tomorrow!!
Complete Entity structure redesign

After previous experience with Entities and their complex and varied
needs (Player needs tick() but Planet doesn't), I realized that as this
game/engine increases in complexity, the Entity structure will get more
and more jumbled. This, coupled with my recent plunge into Unity3D, has
caused me to rethink the whole structure.

Entity is now an instantiatable class. An Entity's behavior is dictated
by its arbitrary number of Components (no, not awt components). A
component can be anything from a physics implementation to a hitbox to a
joint to an image to a script. Anything that is a distinct part of an
Entity is a Component. The Entity class itself spends its time managing
these Components and not really doing much other than being the place
where they all come together. Any Component can access any other
Component provided they belong to the same Entity, because Components
all hold a reference to the Entity that owns them.

Scripts are now a distinct concept from the rest of the classes. To
write a script you make a class a subclass of Script and override any
number of methods inherited from the Script class, including tick() and
init(). In these methods you make the script do what you want.

This should allow the addition of any number of new Components in the
future without even having to think about previously created objects.