Added ability to see if tasks are ready to run, and to clear the task queue
Also added javadocs for protected functions
Fixed 2.0.0 regression in NoThreadScheduler with adding tasks that already have tasks of the same delay in them
Because the clock may advance for getting the delay of existing tasks, we need to be willing to check <= and not just == when finding the insertion index.  That way we are ensure that new tasks are added after existing tasks with the same expected delay.

I also added javadoc to the protected .tick() to indicate it is NOT thread safe
This resolves #86.
I decided to just document the condition, as I feel that it is unlikely anyone would need to call .tick() in parallel, and if they do, they can always put their own wrapper that synchronized to block the call.  In general I would like to keep the locking low, and the performance high.
Further improvment on inserting at a correct point in the NoThreadScheduler
This includes a nice performance improvement because we are not querying for accurate time as frequently.
This also changes it so that if the clock advances (by a little or a lot) while looking for the insertion point, we will be more tollerant to find the insertion point.
I am not 100% confident in this ability yet, but in theory in the future we could do something similar as this for the PriorityScheduledExecutor
Renamed PriorityScheduledExecutor into PriorityScheduler
This is more consistent, and more concise.
Revert "Renamed PriorityScheduledExecutor into PriorityScheduler"

Since we did not include this in 1.3.0, and since PriorityScheduledExecutor is closer to java.util.concurrent.ScheduledThreadPoolExecutor, we will just keep the name for now.  I filed #87 to consider this further.

This reverts commit c7c27eafa9f02c1cf652bfaffae8c65f5312b3a1.
This fixes #85
Our logic was flipped for checking if we needed to look to add workers.  In addition we had an off by one for adding those workers, as well as prestarting the core threads.
I also found a small optimization chance to reduce the clock lookups when trying to get get an existing worker.
Added to ExceptionUtils the ability to write a string from a StackTraceElement array
This also includes unit tests, and will change the format returned from the profiler to match the one we are using in ExceptionUtils
This implementation may have been allowing out of order execution...removing it for now till we can debug it further
Fix for checkstyle warning
StackTraceElement toString is basically what we were doing already, so simplified that
Added unit tests to verify that executions happen in order
Our limiters were violating this unit test.  So for the normal limiters this was fixed.  For the rate limiter I still want to think harder about if this makes sense, and why it may be broken.
Fixed the RateLimiterExecutor executeInOrderTest
This actually led to a much simpler implementation of the limiter, and probably much more efficent as well.  So overall it was a good thing to push harder on this
Changes to make sure the delay in the queue remains constant while inserting into the task queue.
This is what we do in the PriorityScheduledExecutor.  I do feel it is a bit awkward, hacky, and complicated.  So I would like to improve this in the future, but this seems to be at least technically correct.
I also made the ClockWrapper instance based instead of static, that way we will have less contention and interaction from possible multiple instances.
More consistent naming with the clock class, using accurateTimeMillis instead of just accurateTime
Fix for checkstyle warning
Further code duplication reduction by making an AbstractSubmitterScheduler
Just moving these functions into the abstract implementation
Since only one class was extending the AbstractTicableScheduler, I removed it and put the implementation into NoThreadScheduler (which is still written in a way to be easily extended)
Merge branch 'master' into gradle-2.0_updates