Remove bad assert

Seems this assert was typoed, and was accidentally asserting the
nullness of something which is definitely not null.  This was causing
a number of false negatives when the tests were run with assertions
enabled.

Note that this commit completely removes the null checking since it
can't do any good: this code would NPE earlier if line was null.
Untag a batch of passing tests

These were failing on CI due to a bad assert.  Untag them now that the
offending assert is gone.  Note: there my be other tests which are
also clean now that the assert is gone.  Will check for them soon.
Merge pull request #760 from dmarcotte/bad-assert

Remove a bad assert and untag some tests it was affecting
binwrite should pass write only when options are not empty but don't have a "mode"
IO.sysopen accepts mode & permission that are nil
Merge pull request #763 from josedonizetti/io_binwrite

binwrite should pass write only when options are not empty but don't have a "mode"
add support for options and not truncating offset for IO.write
Merge pull request #766 from josedonizetti/sysopen_accepts_mode_and_permission_nil

IO.sysopen accepts mode & permission that are nil
Merge pull request #764 from josedonizetti/io_write

add support for options and not truncating offset for IO.write
raise ArgumentError when IO.new/IO.open last argument is not a hash or nil
Merge pull request #768 from josedonizetti/io_new_wrong_last_argument

raise ArgumentError when IO.new/IO.open last argument is not a hash or nil
Start enabling variable reification logic plus logging of vars.
Remove unused direct ByteBuffer.
when path start with prefix "file:" should strip it and create
hack to avoid ByteList to throw ArrayOutOfBoundsException
bump to dev bytelist
Initial implementation of packed object layout for instance vars.

This implementation supports a packed layout for objects that will
use up to 5 instance variable slots, based on a static inspection
of instance methods at first allocation. Rather than generating
new classes at runtime, I opted to create a chain of objects with
generic field names (var0, var1) to represent various sizes of
packed objects. The appropriate size is chosen by walking all
instance methods in the object's metaclass and superclasses upon
first allocation, examining AST nodes for instance-variable sets
and gets. This gives us a good idea of how many variables will be
used during the object's lifetime, and in many (most) cases we
will not need to allocate the growable varTable (Object[]) to hold
unencountered variables.

This implementation is still in early days, and has the following
limitations:

* Only interpreted methods can be inspected. Methods that are
  AOT-compiled (such as from immediately compiling the command-
  line script) cannot be inspected for instance variable accesses.
  We can remedy this by having AOT-compiled methods also report a
  list of instance variable names they may access.
* Only up to five vars are supported. Objects that use more than
  five variables will start to fall back on the old array-based
  table.
* Reified variable count is not subtracted from the size of the
  array-based table. If an object requires six variables, for
  example, the base object will provide five fields for var0..var4
  and the varTable array will provide room for six elements even
  though the first five will not be used. This should be fixed.
* No testing has been done, and this implementation likely does
  not mesh properly with special variables (object_id, etc),
  marshalling, and other deep accesses of the old array-based
  table that have not been updated to be aware of packed objects.

For a performance, memory-size, and GC overhead comparison, see
the following gist: https://gist.github.com/headius/5681716
Merge remote-tracking branch 'github/master'
Improvements and expansion of reified variable logic.

* Expand to ten variables.
* Move variable-inspection data into MethodData, in prep for
  adding same data into compiled methods.
* Reduce number of switches required to handle reified vars.
Fixes to allocator logic for reified variables.