NavigableSet and NavigableMap were added to Mustang to rectify deficiencies in SortedSet and SortedMap.  
Unfortunately, they did not quite solve the problems.  
There was no way to get a navigable descending view of a navigable collection.  
Further, there was no way to get any partial view other than a half-open ascending set or map.  
Getting another type of interval required horrible hackery that didn't work for some types, 
as per the SortedSet documentation:

--------------------------------------------------------------
Note: this method always returns a half-open range 
(which includes its low endpoint but not its high endpoint). 
If you need a closed range (which includes both endpoints), 
and the element type allows for calculation of the successor a given value, 
merely request the subrange from lowEndpoint to successor(highEndpoint). 
For example, suppose that s is a sorted set of strings. 
The following idiom obtains a view containing all of the strings in s from low to high, inclusive:

   SortedSet sub = s.subSet(low, high+"\0");
 

A similar technique can be used to generate an open range (which contains neither endpoint). 
The following idiom obtains a view containing all of the Strings in s from low to high, exclusive:

   SortedSet sub = s.subSet(low+"\0", high);
-------------------------------------------------------------

The solution to all of these problems is straightforward, and actually simplifies the interfaces:

In NavigableMap, we replace the method:

    Set<Map.Entry<K,V>> descendingEntrySet()

with a single method:

    NavigableMap<K,V> descendingMap();

Further, we take the three "partial view methods":

    NavigableMap<K,V> navigableHeadMap(K toKey);
    NavigableMap<K,V> navigableTailMap(K fromKey);
    NavigableMap<K,V> navigableSubMap(K fromKey, K toKey);

and add parameters to specify whether the endpoints are to be included in the returned view:

    NavigableMap<K,V> headMap(K toKey, boolean inclusive);
    NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
    NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                             K toKey,   boolean toInclusive);

(the removal of the "navigable" prefix here makes for more usable names)

That's it for NavigableMap. The changes to NavigableSet are similar:

We add:

    NavigableSet<E> descendingSet();

Also, "inclusive" parameters are added to the three "partial view" methods:

    NavigableSet<E> headSet(E toElement, boolean inclusive);
    NavigableSet<E> tailSet(E fromElement, boolean inclusive);
    NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                           E toElement,   boolean toInclusive);

The power and elegance of the interfaces are greatly enhanced. 

It is particularly important that we get these changes into Mustang, as these are *interfaces*.  
Once released, they cannot be changed.  
Moreover, they are replacements for existing interfaces (SortedSet and SortedMap done right).  
We will not get a third chance.