docs(generics): explain upper-bounded wildcards (? extends T) in Java

WHAT:
- Added detailed documentation explaining the concept of **upper-bounded wildcards** in Java Generics.
- Clarified syntax, purpose, and real-world usage scenarios.

DETAILS:
- Syntax: `<? extends SomeClass>` → type can be `SomeClass` or any subclass.
- Example context: `List<? extends Number>` allows `Integer`, `Double`, `Float`, etc.
- Focused on the *read-only* nature of collections with `? extends T`
  (safe for reading, not for adding new elements).
- Explained how this pattern represents **covariance** in Java Generics.

WHY:
- Prevents code duplication by allowing methods to handle collections of multiple subtypes.
- Ensures type safety when processing hierarchies (e.g., `Number` and its subclasses).
- Ideal when you need to **consume** or **process** data but not **insert** into the collection.

REAL-WORLD USE:
- Processing lists of numeric values (e.g., `List<Integer>`, `List<Double>`) with a single utility method.
- Useful in mathematical libraries, data aggregation, and reporting systems where inputs
  may vary but are all subtypes of a common parent class.

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

Author: Someshdiwan

Section24JavaGenerics/src/UpperBoundedWildcards/Upper-Bounded Wildcards.txt

@@ -0,0 +1,20 @@
+In Java Generics, an upper-bounded wildcard restricts the types that can be passed as arguments to a parameterized type.
+
+We use the wildcard ? with an upper bound to indicate that the type can be any class that is a subclass of a specified
+class (including the class itself).
+
+The syntax for upper-bounded wildcards is:
+
+<? extends SomeClass>
+This means that the type parameter can be any type that is SomeClass or a subclass of SomeClass.
+
+Why Use Upper-Bounded Wildcards?
+
+Upper-bounded wildcards are useful when you want to read data from a generic structure but you don’t need to modify it
+(except in certain restricted ways).
+
+This is sometimes referred to as “covariance.”
+
+For example, if you have a method that processes a list of numbers,
+but it doesn’t need to add any new elements to the list, you can use an upper-bounded wildcard to
+allow the method to accept lists of Integer, Double, or any other subtype of Number.