refactor: improve code quality - fix imports, type hints, and security issues

## Critical Fixes
- Create error_handler module with custom exceptions and recovery strategies
  - Adds RetryableError, NonRetryableError, NetworkError, DownloadError
  - Implements with_error_recovery decorator for automatic retry logic
  - Provides RecoveryStrategies and FileCorruptionDetector classes
  - Fixes critical import error in enhanced_provider.py

- Fix CORS security vulnerability in fastapi_app.py
  - Replace allow_origins=['*'] with environment-based config
  - Use settings.cors_origins for production configurability
  - Add security warnings in code comments

## Type Hints Improvements
- Fix invalid type hint syntax in Provider.py
  - Change (str, [str]) to tuple[str, dict[str, Any]]
  - Rename GetLink() to get_link() (PEP8 compliance)
  - Add comprehensive docstrings for abstract method

- Update streaming provider implementations
  - voe.py: Add full type hints, update method signature
  - doodstream.py: Add full type hints, update method signature
  - Fix parameter naming (embededLink -> embedded_link)
  - Both now return tuple with headers dict

- Enhance base_provider.py documentation
  - Add comprehensive type hints to all abstract methods
  - Add detailed parameter documentation
  - Add return type documentation with examples

## Files Modified
- Created: src/core/error_handler.py (error handling infrastructure)
- Modified: 9 source files (type hints, naming, imports)
- Added: QUALITY_IMPROVEMENTS.md (implementation details)
- Added: TEST_VERIFICATION_REPORT.md (test status)
- Updated: QualityTODO.md (progress tracking)

## Testing
- All tests passing (unit, integration, API)
- No regressions detected
- All 10+ type checking violations resolved
- Code follows PEP8 and PEP257 standards

## Quality Metrics
- Import errors: 1 -> 0
- CORS security: High Risk -> Resolved
- Type hint errors: 12+ -> 0
- Abstract method docs: Minimal -> Comprehensive
- Test coverage: Maintained with no regressions

src/core/providers/streaming/doodstream.py

@@ -1,59 +1,81 @@
-import re
 import random
+import re
 import time
+from typing import Any
 
-from fake_useragent import UserAgent
 import requests
+from fake_useragent import UserAgent
+
 from .Provider import Provider
+
+
 class Doodstream(Provider):
+    """Doodstream video provider implementation."""
 
     def __init__(self):
         self.RANDOM_USER_AGENT = UserAgent().random
 
-    def GetLink(self, embededLink: str, DEFAULT_REQUEST_TIMEOUT: int) -> str:
+    def get_link(
+        self, embedded_link: str, timeout: int
+    ) -> tuple[str, dict[str, Any]]:
+        """
+        Extract direct download link from Doodstream embedded player.
+
+        Args:
+            embedded_link: URL of the embedded Doodstream player
+            timeout: Request timeout in seconds
+
+        Returns:
+            Tuple of (direct_link, headers)
+        """
         headers = {
-            'User-Agent': self.RANDOM_USER_AGENT,
-            'Referer': 'https://dood.li/'
+            "User-Agent": self.RANDOM_USER_AGENT,
+            "Referer": "https://dood.li/",
         }
 
-        def extract_data(pattern, content):
+        def extract_data(pattern: str, content: str) -> str | None:
+            """Extract data using regex pattern."""
             match = re.search(pattern, content)
             return match.group(1) if match else None
 
-        def generate_random_string(length=10):
-            characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-            return ''.join(random.choice(characters) for _ in range(length))
+        def generate_random_string(length: int = 10) -> str:
+            """Generate random alphanumeric string."""
+            characters = (
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+            )
+            return "".join(random.choice(characters) for _ in range(length))
 
         response = requests.get(
-            embededLink,
+            embedded_link,
             headers=headers,
-            timeout=DEFAULT_REQUEST_TIMEOUT,
-            verify=False
+            timeout=timeout,
+            verify=False,
         )
         response.raise_for_status()
 
         pass_md5_pattern = r"\$\.get\('([^']*\/pass_md5\/[^']*)'"
         pass_md5_url = extract_data(pass_md5_pattern, response.text)
         if not pass_md5_url:
-            raise ValueError(
-                f'pass_md5 URL not found using {embededLink}.')
+            raise ValueError(f"pass_md5 URL not found using {embedded_link}.")
 
         full_md5_url = f"https://dood.li{pass_md5_url}"
 
         token_pattern = r"token=([a-zA-Z0-9]+)"
         token = extract_data(token_pattern, response.text)
         if not token:
-            raise ValueError(f'Token not found using {embededLink}.')
+            raise ValueError(f"Token not found using {embedded_link}.")
 
         md5_response = requests.get(
-            full_md5_url, headers=headers, timeout=DEFAULT_REQUEST_TIMEOUT, verify=False)
+            full_md5_url, headers=headers, timeout=timeout, verify=False
+        )
         md5_response.raise_for_status()
         video_base_url = md5_response.text.strip()
 
         random_string = generate_random_string(10)
         expiry = int(time.time())
 
-        direct_link = f"{video_base_url}{random_string}?token={token}&expiry={expiry}"
-        # print(direct_link)
+        direct_link = (
+            f"{video_base_url}{random_string}?token={token}&expiry={expiry}"
+        )
 
-        return direct_link
+        return direct_link, headers