fix: Relax SearchResult validation to support DBSF fusion scores > 1.0

Fix false-positive validation error where DBSF (Distribution-Based Score
Fusion) correctly produces scores > 1.0 but SearchResult validation
incorrectly rejected them.

**Root Cause**: SearchResult.__post_init__() enforced scores in [0.0, 1.0]
range, but DBSF sums normalized scores from multiple retrieval systems
(dense semantic + sparse BM25), resulting in scores like 1.55 when both
systems strongly agree a document is relevant.

**Changes**:
- Relaxed validation to allow any score ≥ 0.0 (algorithms.py:147-157)
- Updated SearchResult and SemanticSearchResult documentation to explain
  score ranges for RRF ([0.0, 1.0]) vs DBSF (unbounded)
- Added comprehensive test coverage for both fusion methods
- Added DBSF fusion option to vector visualization UI
- Updated viz routes and vizApp() to support fusion parameter selection

**Testing**: All 157 unit tests pass, type checking passes, ruff passes

Fixes error: "Configuration error: Score must be between 0.0 and 1.0, got 1.1528953"

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

nextcloud_mcp_server/auth/userinfo_routes.py

@@ -677,12 +677,15 @@ async def user_info_html(request: Request) -> HTMLResponse:
                 return {{
                     query: '',
                     algorithm: 'bm25_hybrid',
+                    fusion: 'rrf',  // Default fusion method for BM25 Hybrid
                     showAdvanced: false,
                     docTypes: [''],  // Default to "All Types"
                     limit: 50,
                     scoreThreshold: 0.0,
                     loading: false,
                     results: [],
+                    expandedChunks: {{}},  // Track which chunks are expanded (result_id -> chunk data)
+                    chunkLoading: {{}},    // Track loading state per result
 
                     async executeSearch() {{
                         this.loading = true;
@@ -696,6 +699,11 @@ async def user_info_html(request: Request) -> HTMLResponse:
                                 score_threshold: this.scoreThreshold,
                             }});
 
+                            // Add fusion parameter for BM25 Hybrid
+                            if (this.algorithm === 'bm25_hybrid') {{
+                                params.append('fusion', this.fusion);
+                            }}
+
                             // Add doc_types parameter (filter out empty string for "All Types")
                             const selectedTypes = this.docTypes.filter(t => t !== '');
                             if (selectedTypes.length > 0) {{
@@ -778,6 +786,51 @@ async def user_info_html(request: Request) -> HTMLResponse:
                             default:
                                 return `${{baseUrl}}`;
                         }}
+                    }},
+
+                    hasChunkPosition(result) {{
+                        // Check if result has position metadata
+                        return result.chunk_start_offset != null && result.chunk_end_offset != null;
+                    }},
+
+                    isChunkExpanded(resultKey) {{
+                        return this.expandedChunks[resultKey] !== undefined;
+                    }},
+
+                    async toggleChunk(result) {{
+                        const resultKey = `${{result.doc_type}}_${{result.id}}`;
+
+                        // If already expanded, collapse
+                        if (this.isChunkExpanded(resultKey)) {{
+                            delete this.expandedChunks[resultKey];
+                            return;
+                        }}
+
+                        // Otherwise, fetch and expand
+                        this.chunkLoading[resultKey] = true;
+
+                        try {{
+                            const params = new URLSearchParams({{
+                                doc_type: result.doc_type,
+                                doc_id: result.id,
+                                start: result.chunk_start_offset,
+                                end: result.chunk_end_offset,
+                                context: 500  // 500 chars before/after
+                            }});
+
+                            const response = await fetch(`/app/chunk-context?${{params}}`);
+                            const data = await response.json();
+
+                            if (data.success) {{
+                                this.expandedChunks[resultKey] = data;
+                            }} else {{
+                                alert('Failed to load chunk: ' + data.error);
+                            }}
+                        }} catch (error) {{
+                            alert('Error loading chunk: ' + error.message);
+                        }} finally {{
+                            delete this.chunkLoading[resultKey];
+                        }}
                     }}
                 }}
             }}