feat(IdentityHashMapDemo3): demonstrate reference equality in IdentityHashMap

What
- Added IdentityHashMapDemo3 class.
- Shows how IdentityHashMap compares keys using `==` (reference equality) instead of `.equals()`.
- Inserted two different String objects (`new String("key")`) with same content.
- Printed map contents and result of `key1.equals(key2)`.

Why
- To highlight the core difference between HashMap and IdentityHashMap.
- Reinforces that IdentityHashMap treats distinct object references as unique keys even if their contents are equal.
- Useful for scenarios where object identity (not value equality) should determine uniqueness.

How
- Created key1 and key2 with `new String("key")` to guarantee different references.
- map.put(key1,1) followed by map.put(key2,2).
- IdentityHashMap uses reference check → stores both entries.
- Printed results to show both entries are preserved and equals() returns true.

Logic
- Inputs:
  - Two distinct String objects with identical characters.
- Processing:
  - IdentityHashMap checks (k1 == k2).
  - Since key1 != key2 (different references), both are stored as separate entries.
- Outputs:
  - IdentityHashMap contains two entries: `{key=1, key=2}` (order unspecified).
  - `key1.equals(key2)` prints `true`.

Real-life applications
- Useful in frameworks or caches where identity, not logical equality, defines uniqueness.
- Common in serialization frameworks, proxy handling, or object graph traversal where distinct references matter.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Identity HashMap/src/IdentityHashMapDemo3.java

@@ -0,0 +1,28 @@
+import java.util.IdentityHashMap;
+import java.util.Map;
+
+public class IdentityHashMapDemo3 {
+    public static void main(String[] args) {
+        // Two different String objects but with same content "key"
+        String key1 = new String("key");
+        String key2 = new String("key");
+
+        // IdentityHashMap → uses reference equality (==)
+        Map<String, Integer> map = new IdentityHashMap<>();
+
+        map.put(key1, 1);  // First insert
+        map.put(key2, 2);  // Stored separately because key1 != key2 (different objects)
+
+        System.out.println("IdentityHashMap Result: " + map);
+
+        System.out.println(key1.equals(key2));
+    }
+}
+
+//  Using IdentityHashMap (uses == reference comparison).
+
+/* Difference Recap:
+•	HashMap → merges both keys because key1.equals(key2) → true.
+
+•	IdentityHashMap → keeps both entries because key1 == key2 → false.
+*/