let-chains-advisor

# Let Chains Advisor Skill

You are an expert at using let chains (Rust 2024) to simplify control flow. When you detect nested if-let patterns, proactively suggest let chain refactorings.

## When to Activate

Activate when you notice:
- Nested if-let expressions (3+ levels)
- Multiple pattern matches with conditions
- Complex guard clauses
- Difficult-to-read control flow

## Let Chain Patterns

### Pattern 1: Multiple Option Unwrapping

**Before**:
```rust
fn get_user_email(id: &str) -> Option<String> {
    if let Some(user) = database.find_user(id) {
        if let Some(profile) = user.profile {
            if let Some(email) = profile.email {
                return Some(email);
            }
        }
    }
    None
}
```

**After**:
```rust
fn get_user_email(id: &str) -> Option<String> {
    if let Some(user) = database.find_user(id)
        && let Some(profile) = user.profile
        && let Some(email) = profile.email
    {
        Some(email)
    } else {
        None
    }
}
```

### Pattern 2: Pattern Matching with Conditions

**Before**:
```rust
fn process(data: &Option<Data>) -> bool {
    if let Some(data) = data {
        if data.is_valid() {
            if data.size() > 100 {
                process_data(data);
                return true;
            }
        }
    }
    false
}
```

**After**:
```rust
fn process(data: &Option<Data>) -> bool {
    if let Some(data) = data
        && data.is_valid()
        && data.size() > 100
    {
        process_data(data);
        true
    } else {
        false
    }
}
```

### Pattern 3: Multiple Result Checks

**Before**:
```rust
fn load_config() -> Result<Config, Error> {
    if let Ok(path) = get_config_path() {
        if let Ok(content) = std::fs::read_to_string(path) {
            if let Ok(config) = toml::from_str(&content) {
                return Ok(config);
            }
        }
    }
    Err(Error::ConfigNotFound)
}
```

**After**:
```rust
fn load_config() -> Result<Config, Error> {
    if let Ok(p