use L.create() factory to create access-optimized linkedlist objects

Save the setImmediate callback arguments into an array instead of a
closure, and invoke the callback on the arguments from an optimizable
function.

  60% faster setImmediate with 0 args (15% if self-recursive)
  4x faster setImmediate with 1-3 args, 2x with > 3
  seems to be faster with less memory pressure when memory is tight

Changes:
- use L.create() to build faster lists
- use runCallback() from within tryOnImmediate
- create immediate timers with a function instead of new
- just save the arguments and not build closures for the callbacks

Instead of unlinking from the immediate queue immediate on clear,
put off the unlink until processImmediate where it's more efficient.

  3x faster clearImmediate processing

  The the benefits stack with the setImmediate speedups, ie total gain
  of 3.5x with 0 arguments and 4-5x with 1-3 args.

Changed the code to defer unlinking from the immediate queue until
processImmediate consumes the queue anyway.

Timings for sequential and concurren setImmediate with and without
arguments, and set + clearImmediate.

  220% faster yet setImmediate with 4 args,
  240% with 5,
  260% with 6

Changed the code to copy arguments into a dynamically extended array
instead of preallocating the exact size.  It seems f.apply(obj, args)
runs much faster in node v6 if the args array was extended at run-time
as opposed to preallocated the correct size.

This behavior is new in node v6.0.0; v5.10.1 was 4x faster to apply an
args array created the exact size.  (Node v5 and v4 were the other way
around, faster to .apply static sized arrays, and slower if dynamically
grown.)

    // faster to copy args, but v6 slow to .apply them:
    var argv = new Array(arguments.length - 1);   // exact size
    for (var i = 1; i < arguments.length; i++)
      argv[i - 1] = arguments[i];

    // slower to copy args, but v6 much faster to .apply them:
    var argv = new Array();                       // grow as needed
    for (var i = 1; i < arguments.length; i++)
      argv[i - 1] = arguments[i];