Cleanup unused code for finalizers
Fix memory corruption problem with Fiber finalization

The problem is that here ->die() is called on the Fiber, which resets
the thread is is associated too. If then the fiber data is deleted, it
will not remove itself from the fiber stacks list of the thread it
belonged to.

This means that when the FiberStacks are cleaned up for this thread, the
fiber data that has been deallocated is still in the list. That leads to
invalid memory writes in vm/fiber_stack.cpp:72 when it calls ->die()
again on the fiber data.

This is the cause of segfaults on Linux when all finalizers are enabled
when Rubinius shuts down. This fix allows for enabling finalizers
properly.
Enable running all finalizers on process shutdown

We should run all finalizers and not just IO finalizers when Rubinius
shuts down. This means we also have to keep the NativeMethod environment
alive, because the finalizers might do FFI calls such as close().
Mark object as on stack in rbx_meta_to_s
More finalizer cleanup, removes unused code

Happy new year everyone!
String::num_bytes setter already resets num_chars
Ensure cleanup of global handle locations
Rubinius doesn't need to call ruby_init_setproctitle from MRI
Cleanup JIT runtime data properly
Cleanup arguments when exec fails
Add very basic stat and debug options for method cache resets
Remove unused dlmalloc
Use strncpy over strcpy
Remove unused strlcat and strlcpy
Remove unnecessary use of invoke_primitive
Don't mark functions that allocate and could result in GC as read only

These can have side effects if they cause an actual GC because of memory
pressure. In that case it can also for example modify stack addresses
because objects are forwarded. LLVM shouldn't remove those cases.

The proper way to handle this would be to first do escape analysis and
if it doesn't escape, we could switch to stack allocation. That stack
allocation can then properly be seen as having no side effects.
Make debugging easier for Baker GC space

This makes two changes to make some debugging easier. First it marks a
certain as off limits so Valgrind can find errors if objects are used
that still refer to this old space.

The other is that we can easily set a flag to fill the unused space with
all 1's so any usage will very likely result in a segfault and makes
problems appear sooner rather than later.
Make sure to mark the areas as accessible before doing GC
Ensure we delete the condition when the lookup fails
Explicit return 0 compiler snack