RFC: Addition/update of various dictionary, set variants

* `OrderedDict` (new)
* `OrderedSet` (new)
* `DefaultDict` (updated)
* `DefaultOrderedDict` (new)

The basic structure is there, but not yet any tests or documentation.  Bugs are likely still lurking...

cc: @toivoh

**Edit** Here's an account of the evolution of `OrderedDicts`:

I've tried various approaches to implement ordered dicts, and this was pretty much the only one with reasonable performance (about 10% slower than `Dicts`).

Background: In `Dicts`, for efficiency, keys and values are stored in separate arrays, as:

```julia
type Dict{K,V} <: Associative{K,V}
    slots::Array{Uint8,1}
    keys::Array{K,1}
    vals::Array{V,1}
...
```

An easy way to implement `OrderedDicts` is to use a type or tuple for `vals` which contains ordering information (generally, a doubly linked list).  Unfortunately, this kills performance, because `vals` is (generally) no longer contiguous.  (Note that I originally did this long before @loladiro's tuple updates).

So, the most performant method is to include ordering information as part of the `Dict` type.  `HashDict` implements this. It is parametrized as `Ordered` or `Unordered`, which are aliases for `Int` and `Nothing`, respectively.

`Nothing` arrays take up little or no space, so other than two additional variables in the `Dict` type, there is no memory difference and no performance difference between `HashDict{K,V,Unordered}` and`Base.Dict{K,V}`.  (The idea for `Nothing` came from Base.Set.)  Ideally, I'd like to see `Base.Dict` implemented based on `HashDict`.

In https://github.com/JuliaLang/julia/pull/4038, I did this:

```julia
type Dict{K,V,O<:Union(Ordered,Unordered)} <: Associative{K,V}
```
Unfortunately, it had its own issues
   a. Constructing plain `Dicts` using constructor notation always required the `Unordered` type parameter.
   b. `(Type1=>Type2)[]` produced `Dict{Type1,Type2,Unordered}`, which required a bit of mucking around in the parser to get things working.  It was kinda fun, but it takes a bit of work.
   c. `OrderedDict` could be a typealias or constructor, but not both (see https://github.com/JuliaLang/julia/issues/3427)

Given all of this, I chose to make the `HashDict` type, and implement `OrderedDicts` a thin wrapper around it (for aesthetics), and hope that at some point, `HashDict` will become the base for both `Dict` and `OrderedDict`.

============================

One other consideration for the `OrderedDict`/`HashDict` implementation (for the future)

* The current implementation of `HashDict` uses two additional arrays to maintain ordering information:
   *  `order` is an ordering of indices in the `keys`/`vals` array
   * `idxs` is the same size as `keys` and `vals`, and points back into the `order` array, for easy updating
This could allow direct access to the `nth` key-value pair (which was the original inspiration).  

Instead, these could be implemented as `prev` and `next` in a doubly linked list, which might actually allow some simplification.  (Should probably try this.)