SI-5767 fix + small HashSet/HashMap fixes

- `LinkedHashSet` implementation moved from `FlatHashTable` to `HashTable`
   - `remove` time reduced from O(n) to O(1)
   - `diff` time reduced from O(n^2) to O(n)
- A bit of refactoring in `HashTable` serialization code
- Putting an element into hash map now avoids double hash code/hash index
  calculation (see `HashTable#findOrAddEntry`)
- bugfix: compiler/LambdaLift occasionally breaks LinkedHashSet integrity
Rank based take/drop/slice.

Tree navigation based on node rank is faster than using compare
method. rank is simply count(tree.left) + 1.
Making public methods of FlatHashTable protected

As discussed in https://groups.google.com/forum/?pli=1#!topic/scala-internals/1yABM30POS0
Added a heuristic to the inliner.

But it's commented out because I want to get this logging
code into 2.10 without including anything "interesting".
Worked around SI-6161 by annotating abstract type.
Took measures to quiet down specialization logging.

While hopefully still hearing about certain things (like symbol renames)
when it's not a specialized symbol.
Large logging cleanup effort.

Quieted down many logging statements which contribute
disproportionate noise.  Made others emit something more sensible.
Spent lots of time on the inliner trying to find a regular
format to make the logs more readable.  Long way to go here but
it'd be so worth it to have readable logs instead of mind-numbing
indiscriminate text dumps.
several fixes to scala.concurrent.util.Duration

- add test cases (migrated from Akka sources)
- add overflow checking (will throw IllegalArgumentException instead of
  giving wrong results)
- make string parsing more precise when giving >100days in nanoseconds
- make method signatures more precise in retaining FiniteDuration
  throughout calculations
- fix mul/div of infinities by negative number
- add Ordering for Deadline (was accidentally left out earlier)
Fixes SI-6271 - Missing isEmpty override for views.

GenIterableView didn't override isEmpty for views to look at *filtered* iterator, but was instead pulling
unfiltered iterator and causing issues.   Chalk up another bizzare bug to lack of insight/visibility into
linearization and what havoc overriding new methods can spew on our library.
test suite for SI-6329
second round of Duration cleanup

- make Duration behave consistent with Double's non-finite semantics
- add ScalaDoc
- add complete test suite
- change overflow protection impl after review comments
- clean up code
fix some one more issue in Duration

- Inf / Zero == Inf
- add some more missing test cases
- clarify magic constant
- move exception descriptions into proper @throws docs
SI-6331 Avoid typing an If tree with a constant type.

The fast path in typedIf added in 8552740b avoided lubbing the if/else branch types
if they are identical, but this fails to deconst the type. This could lead to the entire
if expression being replaced by a constant.

Also introduces a new tool in partest for nicer checkfiles.

// in Test.scala
trace(if (t) -0d else 0d)

// in Test.check
trace> if (Test.this.t)
  -0.0
else
  0.0
res: Double = -0.0
Refine equality of Constant types over floating point values.

The constant types for 0d and -0d should not be equal.

This is implemented by checking equality of the result of
doubleToRawLongBits / floatToRawIntBits, which also correctly
considers two NaNs of the same flavour to be equal.

Followup to SI-6331.
fix two minor issues in Duration

- make constants for fromNanos(Long) actually inlined constants
- clarify origin of require() check constants in FiniteDuration
Test for consistency of Constant#{equals, hashCode}.

For the examples I've constructed, they are consistent, but
I put this down to good luck, rather than good management.
The next commit will address this.
Improve Constant#hashCode

 - Incorporate `tag`, which is considered by equals, to reduce collisions.
 - Use the result of floatToRawIntBits(value) / doubleToRawLongBits(value),
    rather than value. This wasn't strictly necessary as (0d.## == (-0d).##)
    but this is more obviously correct.
SI-6335 More precise location of the implicit class synthetic method.

One approach would be to disallow an implicit class in a template
that already has a member with the same name.

But this commit doesn't do this; instead it uses `isSynthetic` to
find the synthesized implicit conversion method from the potentially
overloaded alternatives.
More tests for SI-6335.
SI-6276 Warn on def or val that trivially loops infinitely