feat(StrongReferenceDemo): add demo of strong references and GC eligibility

What
- Added `StrongReferenceDemo` class.
- Created `Phone` object with strong reference.
- Printed object when strongly referenced.
- Set reference to null and printed again.

Why
- To demonstrate how strong references work in Java.
- Show that as long as a strong reference exists, the object is not garbage collected.
- Illustrate that nullifying the reference makes the object eligible for GC.

How
- Step 1: Create strong reference `phone` → new Phone("Apple", "16 Pro Max").
- Step 2: Print object via strong reference.
- Step 3: Nullify reference (`phone = null`).
- Step 4: Print reference again (shows null).
- Garbage collector can now reclaim the object since no strong references exist.

Logic
- Inputs:
  - Phone constructor with brand and model.
- Outputs:
  - Console logs showing object before and after nullifying reference.
- Flow:
  1. Allocate Phone on heap.
  2. Reference with strong variable.
  3. Print reference.
  4. Set to null, making object unreachable.
- Constraints:
  - Actual GC execution is JVM-dependent and not forced by this demo.
- Complexity:
  - O(1) for reference assignment and printing.

Real-life applications
- Strong references are the default in Java.
- Used for normal object handling in applications.
- Important to nullify or let references go out of scope to allow GC in long-lived structures.

Notes
- Strong reference = default reference type in Java.
- Objects with strong refs are **never** collected by GC.
- To allow collection, references must be explicitly cleared or go out of scope.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Garbage Collection/src/StrongReferenceDemo.java

@@ -0,0 +1,19 @@
+public class StrongReferenceDemo {
+    public static void main(String[] args) {
+        // Create a strong reference to a Phone object.
+        Phone phone = new Phone("Apple", "16 Pro Max");
+
+        // At this point, 'phone' strongly refers to the Phone object in heap.
+        System.out.println("Phone via strong reference: " + phone);
+
+        // Nullify the reference, making the object eligible for GC.
+        phone = null;
+
+        // Now the Phone object has no references → eligible for GC.
+        System.out.println("After nullifying reference: " + phone);
+    }
+}
+
+// Demonstrates how strong references work in Java.
+// A strong reference prevents an object from being garbage collected
+// until the reference is explicitly set to null or goes out of scope.