perspt 0.4.1

# UI Buffering and Response Display Fixes

## Issues Fixed

### 1. **Event Loop Optimization**
**Problem**: The event loop was using a zero timeout (`Duration::from_millis(0)`) which caused excessive CPU usage and delayed processing of LLM responses.

**Solution**: 
- Changed event polling timeout to 10ms for better balance between responsiveness and CPU efficiency
- Restructured the `tokio::select!` priorities to handle LLM responses with highest priority
- Added separate render interval (16ms ~60fps) for smooth animations

### 2. **Immediate Response Rendering**
**Problem**: Long LLM responses weren't displayed until subsequent user questions due to event loop blocking.

**Solution**:
- **Immediate Redraw**: LLM responses now trigger immediate terminal redraw
- **Priority Handling**: LLM message handling has highest priority in the event loop
- **Force Rendering**: Added forced rendering after each streaming update

### 3. **Enhanced Content Buffering**
**Problem**: Streaming content wasn't properly preserved when the buffer was cleared too early.

**Solution**:
- **Improved `update_streaming_content()`**: Now properly updates existing assistant messages and ensures content visibility
- **Enhanced `finish_streaming()`**: Preserves final content before clearing the buffer
- **Timeline Update**: Updates message timestamps for latest content

### 4. **Better Scroll Management**
**Problem**: Auto-scrolling wasn't working properly with dynamic content, causing display issues.

**Solution**:
- **Dynamic Bounds**: Improved scroll position calculation based on actual content height
- **Auto-correction**: Ensures scroll position stays within valid bounds when content changes
- **Enhanced Visibility**: Better scroll-to-bottom behavior for new content

### 5. **Event Stream Improvements**
**Problem**: Zero-timeout polling caused the UI to be unresponsive and consume excessive CPU.

**Solution**:
```rust
// Before: Immediate polling (CPU intensive)
if let Ok(true) = event::poll(Duration::from_millis(0)) {

// After: Balanced timeout (responsive + efficient)
if let Ok(true) = event::poll(Duration::from_millis(10)) {
```

## Key Code Changes

### Event Loop Priority Structure
```rust
tokio::select! {
    // Highest priority: LLM responses for real-time streaming
    llm_message = rx.recv() => {
        handle_llm_response(&mut app, message, &provider, &model_name, &tx).await;
        // Force immediate redraw
        terminal.draw(|f| draw_enhanced_ui(f, &mut app, &model_name))?;
    }
    
    // Second priority: User input events
    event_result = event_stream.next() => {
        // Handle keyboard input with immediate feedback
    }
    
    // Third priority: Regular rendering updates
    _ = render_interval.tick() => {
        // Smooth animations and cursor blinking
    }
}
```

### Enhanced Streaming Content Management
```rust
pub fn update_streaming_content(&mut self, content: &str) {
    self.streaming_buffer.push_str(content);
    
    // Update existing assistant message or create new one
    if let Some(last_msg) = self.chat_history.last_mut() {
        if last_msg.message_type == MessageType::Assistant {
            last_msg.content = markdown_to_lines(&self.streaming_buffer);
            last_msg.timestamp = Self::get_timestamp(); // Update for latest content
        }
    }
    
    self.scroll_to_bottom(); // Ensure visibility
    self.needs_redraw = true;
}
```

### Content Preservation on Stream End
```rust
pub fn finish_streaming(&mut self) {
    // Ensure final content is preserved
    if !self.streaming_buffer.is_empty() {
        if let Some(last_msg) = self.chat_history.last_mut() {
            if last_msg.message_type == MessageType::Assistant {
                last_msg.content = markdown_to_lines(&self.streaming_buffer);
                last_msg.timestamp = Self::get_timestamp();
            }
        }
    }
    
    self.scroll_to_bottom(); // Final scroll to show complete response
    self.streaming_buffer.clear(); // Clear only after preserving content
}
```

## Testing Results

The fixes address the following scenarios:

1. **Long Responses**: LLM responses are now displayed in real-time as they stream in
2. **Multiple Questions**: Users can type new questions while responses are being generated (queued properly)
3. **Content Preservation**: All response content is preserved and displayed correctly
4. **CPU Efficiency**: Reduced CPU usage while maintaining responsiveness
5. **Scroll Behavior**: Auto-scrolling works correctly with dynamic content

## Performance Improvements

- **CPU Usage**: Reduced from high polling frequency to balanced 10ms intervals
- **Responsiveness**: LLM responses display immediately with forced redraws
- **Memory Management**: Better buffer handling prevents content loss
- **UI Smoothness**: 60fps render interval for smooth animations

## Backward Compatibility

All changes are internal to the UI module and maintain the same external API. No breaking changes to:
- Configuration file format
- Command-line arguments
- LLM provider interface
- Message formats