Add plain binary search to maps and sets too

While `IndexMap::binary_search_keys` and `IndexSet::binary_search` don't
scale as well as their corresponding `get_index_of`, O(log n) vs. O(1),
they do still offer the benefit of returning an `Err` insertion point.

src/map.rs

@@ -794,6 +794,21 @@ where
         });
     }
 
+    /// Search over a sorted map for a key.
+    ///
+    /// Returns the position where that key is present, or the position where it can be inserted to maintain the sort.
+    /// See [`slice::binary_search`] for more details.
+    ///
+    /// Computes in **O(log(n))** time,
+    /// which is notably less scalable than looking the key up using [`get_index_of`],
+    /// but this can also position missing keys.
+    pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
+    where
+        K: Ord,
+    {
+        self.as_slice().binary_search_keys(x)
+    }
+
     /// Search over a sorted map with a comparator function.
     ///
     /// Returns the position where that value is present, or the position where it can be inserted to maintain the sort.

src/map/slice.rs

@@ -204,11 +204,12 @@ impl<K, V> Slice<K, V> {
 
     /// Search over a sorted map for a key.
     ///
-    /// Returns the position where that value is present, or the position where it can be inserted to maintain the sort.
+    /// Returns the position where that key is present, or the position where it can be inserted to maintain the sort.
     /// See [`slice::binary_search`] for more details.
     ///
     /// Computes in **O(log(n))** time,
-    /// which is notably less scalable than looking the value up in the map this is a slice from.
+    /// which is notably less scalable than looking the key up in the map this is a slice from
+    /// using [`IndexMap::get_index_of`], but this can also position missing keys.
     pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
     where
         K: Ord,

src/set.rs

@@ -688,6 +688,21 @@ where
         });
     }
 
+    /// Search over a sorted set for a value.
+    ///
+    /// Returns the position where that value is present, or the position where it can be inserted to maintain the sort.
+    /// See [`slice::binary_search`] for more details.
+    ///
+    /// Computes in **O(log(n))** time,
+    /// which is notably less scalable than looking the value up using [`get_index_of`],
+    /// but this can also position missing values.
+    pub fn binary_search(&self, x: &T) -> Result<usize, usize>
+    where
+        T: Ord,
+    {
+        self.as_slice().binary_search(x)
+    }
+
     /// Search over a sorted set with a comparator function.
     ///
     /// Returns the position where that value is present, or the position where it can be inserted to maintain the sort.

src/set/slice.rs

@@ -116,7 +116,8 @@ impl<T> Slice<T> {
     /// See [`slice::binary_search`] for more details.
     ///
     /// Computes in **O(log(n))** time,
-    /// which is notably less scalable than looking the value up in the set this is a slice from.
+    /// which is notably less scalable than looking the value up in the set this is a slice from
+    /// using [`IndexSet::get_index_of`], but this can also position missing values.
     pub fn binary_search(&self, x: &T) -> Result<usize, usize>
     where
         T: Ord,