feat: add ConcurrentSkipListMapDemo with basic example

What
- Introduced `ConcurrentSkipListMapDemo` class.
- Demonstrated use of `ConcurrentSkipListMap` via its `NavigableMap` interface.
- Inserted a few entries and printed them in natural sorted order.

Why
- Complements `ConcurrentHashMapDemo` by showing a concurrent map that preserves ordering.
- Highlights a scalable, thread-safe alternative to `TreeMap` when ordering is needed.
- Provides a simple reference for concurrency + ordering in collections.

How
- Created a `ConcurrentSkipListMap<Integer, String>`.
- Populated it with keys `2,1,3`.
- Printed the map to show that entries are maintained in ascending key order.

Logic
- `ConcurrentSkipListMap` internally uses a skip list to maintain sorted keys.
- Iteration order is sorted by natural ordering or provided comparator.
- Thread-safe without needing explicit synchronization.

Real-world applications
- Suitable for concurrent caches or lookup tables requiring both fast access and sorted keys.
- Useful for range queries (e.g., `headMap`, `tailMap`) in multithreaded contexts.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Concurrent HashMap/Concurrent Skip List Map/src/ConcurrentSkipListMapDemo.java

@@ -0,0 +1,33 @@
+import java.util.NavigableMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+
+/**
+ * Small demo class to complement {@link ConcurrentHashMapDemo}.
+
+ * <p>
+ * ConcurrentSkipListMap provides a thread-safe sorted map (ordered by natural ordering
+ * or provided Comparator). It is a scalable concurrent alternative to TreeMap when you
+ * need both ordering and concurrency.
+ * </p>
+
+ * <p>
+ * This class provides a minimal stand-in for documentation purposes and for the
+ * {@code @see} reference in {@link ConcurrentHashMapDemo}. It intentionally contains
+ * only a short example that prints a small concurrent, sorted map.
+ * </p>
+ */
+
+public class ConcurrentSkipListMapDemo {
+    public static void main(String[] args) {
+        // Create a thread-safe, sorted map backed by a skip list.
+        NavigableMap<Integer, String> skipListMap = new ConcurrentSkipListMap<>();
+
+        // Populate with a few entries (kept simple for demonstration).
+        skipListMap.put(2, "Two");
+        skipListMap.put(1, "One");
+        skipListMap.put(3, "Three");
+
+        // Prints the map (will be in sorted key order: 1, 2, 3).
+        System.out.println(skipListMap);
+    }
+}