feat(HashtableEnumerationDemo): add demo of legacy Enumeration iteration with Hashtable

What
- Added `HashtableEnumerationDemo` to showcase iterating over a `Hashtable` using `Enumeration`.
- Populated table with entries: (1→"A"), (2→"BZ"), (3→"C"), (7→"Z7").
- Enumerated values with `ht.elements()`.
- Enumerated keys with `ht.keys()`.
- Printed results sequentially.

Why
- To demonstrate the legacy `Enumeration` API still supported by `Hashtable`.
- Highlights the difference from modern iteration (`Iterator`, `forEach`).
- Educational example of synchronized legacy collections and how they were iterated pre-Java 2.

How
- Step 1: Create generic `Hashtable<Integer,String>`.
- Step 2: Insert four entries.
- Step 3: Call `ht.elements()` to retrieve `Enumeration<String>` of values.
- Step 4: Iterate using `while(valuesEnum.hasMoreElements())`.
- Step 5: Call `ht.keys()` to retrieve `Enumeration<Integer>` of keys.
- Step 6: Iterate and print each key.

Logic
- Inputs: hard-coded key–value pairs.
- Outputs:
  - Console logs values: `"A"`, `"BZ"`, `"C"`, `"Z7"` (order not guaranteed).
  - Console logs keys: `1, 2, 3, 7` (order not guaranteed).
- Flow:
  1. Insert entries.
  2. Enumerate values.
  3. Enumerate keys.
- Enumeration is forward-only, does not support remove or fail-fast semantics.

Real-life applications
- Maintaining or reading legacy codebases where `Hashtable` + `Enumeration` are used.
- Simple demos showing historical evolution from `Enumeration` to `Iterator`/`Stream`.
- Rarely used in production; modern APIs offer more functionality and safety.

Notes
- `Hashtable` is synchronized (all methods thread-safe).
- `Enumeration` is not fail-fast: concurrent modifications do not throw `ConcurrentModificationException`.
- Prefer `forEach`, `entrySet().iterator()`, or streams in new code.
- Demonstrates backward compatibility in Java Collections Framework.

Signed-off-by: https://github.com/Someshdiwan <someshdiwan369@gmail.com>

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Hash Table/src/HashtableEnumerationDemo.java

@@ -0,0 +1,38 @@
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class HashtableEnumerationDemo {
+    public static void main(String[] args) {
+        Hashtable<Integer, String> ht = new Hashtable<>();
+        ht.put(1, "A");
+        ht.put(2, "BZ"); // assume compute already applied
+        ht.put(3, "C");
+        ht.put(7, "Z7");
+
+        // Enumeration of values
+        Enumeration<String> valuesEnum = ht.elements();
+
+        System.out.println("Values via Enumeration:");
+        while (valuesEnum.hasMoreElements()) {
+            String val = valuesEnum.nextElement();
+            System.out.println(val);
+        }
+
+        // Enumeration of keys
+        Enumeration<Integer> keysEnum = ht.keys();
+
+        System.out.println("\nKeys via Enumeration:");
+        while (keysEnum.hasMoreElements()) {
+            Integer k = keysEnum.nextElement();
+            System.out.println(k);
+        }
+
+        /*
+         - Enumeration is the old style for iterating Hashtable.
+         - For modern collections prefer Iterator or forEach.
+         - Hashtable is synchronized; Enumeration does not support fail-fast semantics like Iterator.
+           iterating values() and keys(), Shows legacy-style iteration used with Hashtable
+           (Enumeration rather than Iterator).
+        */
+    }
+}