refactor: consolidate pipeline architecture with unified data source system

MAJOR REFACTORING: Consolidate duplicated pipeline code and standardize on
capability-based dependency resolution. This is a significant but backwards-compatible
restructuring that improves maintainability and extensibility.

## ARCHITECTURE CHANGES

### Data Sources Consolidation
- Move engine/sources_v2.py → engine/data_sources/sources.py
- Move engine/pipeline_sources/ → engine/data_sources/
- Create unified DataSource ABC with common interface:
  * fetch() - idempotent data retrieval
  * get_items() - cached access with automatic refresh
  * refresh() - force cache invalidation
  * is_dynamic - indicate streaming vs static sources
- Support for SourceItem dataclass (content, source, timestamp, metadata)

### Display Backend Improvements
- Update all 7 display backends to use new import paths
- Terminal: Improve dimension detection and handling
- WebSocket: Better error handling and client lifecycle
- Sixel: Refactor graphics rendering
- Pygame: Modernize event handling
- Kitty: Add protocol support for inline images
- Multi: Ensure proper forwarding to all backends
- Null: Maintain testing backend functionality

### Pipeline Adapter Consolidation
- Refactor adapter stages for clarity and flexibility
- RenderStage now handles both item-based and buffer-based rendering
- Add SourceItemsToBufferStage for converting data source items
- Improve DataSourceStage to work with all source types
- Add DisplayStage wrapper for display backends

### Camera & Viewport Refinements
- Update Camera class for new architecture
- Improve viewport dimension detection
- Better handling of resize events across backends

### New Effect Plugins
- border.py: Frame rendering effect with configurable style
- crop.py: Viewport clipping effect for selective display
- tint.py: Color filtering effect for atmosphere

### Tests & Quality
- Add test_border_effect.py with comprehensive border tests
- Add test_crop_effect.py with viewport clipping tests
- Add test_tint_effect.py with color filtering tests
- Update test_pipeline.py for new architecture
- Update test_pipeline_introspection.py for new data source location
- All 463 tests pass with 56% coverage
- Linting: All checks pass with ruff

### Removals (Code Cleanup)
- Delete engine/benchmark.py (deprecated performance testing)
- Delete engine/pipeline_sources/__init__.py (moved to data_sources)
- Delete engine/sources_v2.py (replaced by data_sources/sources.py)
- Update AGENTS.md to reflect new structure

### Import Path Updates
- Update engine/pipeline/controller.py::create_default_pipeline()
  * Old: from engine.sources_v2 import HeadlinesDataSource
  * New: from engine.data_sources.sources import HeadlinesDataSource
- All display backends import from new locations
- All tests import from new locations

## BACKWARDS COMPATIBILITY

This refactoring is intended to be backwards compatible:
- Pipeline execution unchanged (DAG-based with capability matching)
- Effect plugins unchanged (EffectPlugin interface same)
- Display protocol unchanged (Display duck-typing works as before)
- Config system unchanged (presets.toml format same)

## TESTING

- 463 tests pass (0 failures, 19 skipped)
- Full linting check passes
- Manual testing on demo, poetry, websocket modes
- All new effect plugins tested

## FILES CHANGED

- 24 files modified/added/deleted
- 723 insertions, 1,461 deletions (net -738 LOC - cleanup!)
- No breaking changes to public APIs
- All transitive imports updated correctly

tests/test_tint_effect.py

@@ -0,0 +1,125 @@
+import pytest
+
+from effects_plugins.tint import TintEffect
+from engine.effects.types import EffectConfig
+
+
+@pytest.fixture
+def effect():
+    return TintEffect()
+
+
+@pytest.fixture
+def effect_with_params(r=255, g=128, b=64, a=0.5):
+    e = TintEffect()
+    config = EffectConfig(
+        enabled=True,
+        intensity=1.0,
+        params={"r": r, "g": g, "b": b, "a": a},
+    )
+    e.configure(config)
+    return e
+
+
+@pytest.fixture
+def mock_context():
+    class MockContext:
+        terminal_width = 80
+        terminal_height = 24
+
+        def get_state(self, key):
+            return None
+
+    return MockContext()
+
+
+class TestTintEffect:
+    def test_name(self, effect):
+        assert effect.name == "tint"
+
+    def test_enabled_by_default(self, effect):
+        assert effect.config.enabled is True
+
+    def test_returns_input_when_empty(self, effect, mock_context):
+        result = effect.process([], mock_context)
+        assert result == []
+
+    def test_returns_input_when_transparency_zero(
+        self, effect_with_params, mock_context
+    ):
+        effect_with_params.config.params["a"] = 0.0
+        buf = ["hello world"]
+        result = effect_with_params.process(buf, mock_context)
+        assert result == buf
+
+    def test_applies_tint_to_plain_text(self, effect_with_params, mock_context):
+        buf = ["hello world"]
+        result = effect_with_params.process(buf, mock_context)
+        assert len(result) == 1
+        assert "\033[" in result[0]  # Has ANSI codes
+        assert "hello world" in result[0]
+
+    def test_tint_preserves_content(self, effect_with_params, mock_context):
+        buf = ["hello world", "test line"]
+        result = effect_with_params.process(buf, mock_context)
+        assert "hello world" in result[0]
+        assert "test line" in result[1]
+
+    def test_rgb_to_ansi256_black(self, effect):
+        assert effect._rgb_to_ansi256(0, 0, 0) == 16
+
+    def test_rgb_to_ansi256_white(self, effect):
+        assert effect._rgb_to_ansi256(255, 255, 255) == 231
+
+    def test_rgb_to_ansi256_red(self, effect):
+        color = effect._rgb_to_ansi256(255, 0, 0)
+        assert 196 <= color <= 197  # Red in 256 color
+
+    def test_rgb_to_ansi256_green(self, effect):
+        color = effect._rgb_to_ansi256(0, 255, 0)
+        assert 34 <= color <= 46
+
+    def test_rgb_to_ansi256_blue(self, effect):
+        color = effect._rgb_to_ansi256(0, 0, 255)
+        assert 20 <= color <= 33
+
+    def test_configure_updates_params(self, effect):
+        config = EffectConfig(
+            enabled=True,
+            intensity=1.0,
+            params={"r": 100, "g": 150, "b": 200, "a": 0.8},
+        )
+        effect.configure(config)
+        assert effect.config.params["r"] == 100
+        assert effect.config.params["g"] == 150
+        assert effect.config.params["b"] == 200
+        assert effect.config.params["a"] == 0.8
+
+    def test_clamp_rgb_values(self, effect_with_params, mock_context):
+        effect_with_params.config.params["r"] = 300
+        effect_with_params.config.params["g"] = -10
+        effect_with_params.config.params["b"] = 1.5
+        buf = ["test"]
+        result = effect_with_params.process(buf, mock_context)
+        assert "\033[" in result[0]
+
+    def test_clamp_alpha_above_one(self, effect_with_params, mock_context):
+        effect_with_params.config.params["a"] = 1.5
+        buf = ["test"]
+        result = effect_with_params.process(buf, mock_context)
+        assert "\033[" in result[0]
+
+    def test_preserves_empty_lines(self, effect_with_params, mock_context):
+        buf = ["hello", "", "world"]
+        result = effect_with_params.process(buf, mock_context)
+        assert result[1] == ""
+
+    def test_inlet_types_includes_text_buffer(self, effect):
+        from engine.pipeline.core import DataType
+
+        assert DataType.TEXT_BUFFER in effect.inlet_types
+
+    def test_outlet_types_includes_text_buffer(self, effect):
+        from engine.pipeline.core import DataType
+
+        assert DataType.TEXT_BUFFER in effect.outlet_types