docs(core-concepts): add overview of Streams, Collections Framework, and Generics

What
- Added a detailed documentation file covering three foundational Java concepts:
  1. Streams → declarative, functional data processing with filter/map/reduce and parallelism.
  2. Collections Framework → core data structures (List, Set, Map, Queue) and their integration in back-end, front-end, and frameworks.
  3. Generics → type-safety, reusability, and readability improvements with generic classes/interfaces.
- Included structured sections:
  - Concept explanation
  - Practical applications
  - Real-world usage across back-end, microservices, UI, and middleware.
- Provided a concise summary that positions these three concepts as the backbone of scalable Java development.

Why
- These three concepts are central to modern Java programming across domains.
- Developers often use them together (e.g., Collections hold data, Streams process it, Generics enforce type safety).
- A unified overview makes it easier to understand how they interconnect and why mastering them is essential for enterprise-grade applications.

Logic
1. **Streams**
   - Emphasized functional, declarative style over imperative loops.
   - Highlighted back-end data manipulation, parallel computation, and event/log pipelines.
   - Showed relevance in high-throughput systems like Spring Boot services or analytics.

2. **Collections Framework**
   - Identified as the backbone of Java applications.
   - Explained usage in back-end (DB results, caching), front-end/mobile (UI state, adapters), and frameworks (Spring, Hibernate).
   - Reinforced importance as building blocks for nearly all Java data-handling code.

3. **Generics**
   - Explained compile-time type safety preventing runtime ClassCastException.
   - Showed reusability via type-safe repositories, DTOs, and custom utilities.
   - Clarified benefits of reduced boilerplate and increased readability.

4. **Real-World Applications**
   - Connected Streams, Collections, and Generics into enterprise workflows:
     - Back-end data processing (Collections + Streams).
     - Microservices aggregation (Streams + Generics for DTOs).
     - UI/mobile apps (Collections + Generics for model binding).
     - Utility libraries (all three for flexibility and safety).

Real-life applications
- Enterprise back-end: Streams filter/aggregate DB records, Collections cache them, Generics enforce DTO typing.
- Microservices: Streams combine service results, Generics enable reusable interfaces across APIs.
- UI/Mobile apps: Collections model UI data, Streams transform it, Generics prevent runtime casting errors.
- Middleware/utility libraries: Provide type-safe, reusable APIs built on Collections and Generics.

Notes
- ✔ Streams = declarative, functional pipelines for data.
- ✔ Collections = robust, reusable data structures.
- ✔ Generics = compile-time safety + reusable APIs.
- Together, these form the core triad for efficient, scalable, and maintainable Java systems.

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

Author: Someshdiwan