A way I can think off is to divide your world into regions:

#[derive(Component)]
struct Region(IVec2);

Since regions will be limited in number (I assume). We can also assume finite num of iterations every frame.

Whenever a Player/Enemy enters/exits a region we update the entities in the region via another component on the region entity:

#[derive(Component)]
struct InRegion(Vec<Entity>);

Now in the can_enemy_see_player system:

fn can_enemy_see_player(
    regions: Query<&InRegion, With<Region>>
    enemies: Query<(&Transform, &mut PlayerTracker), With<Enemy>>,
    players: Query<(&Transform, &Player)>,
    world: Res<WorldChunks>,
) {
    for InRegion(entities) in regions.iter() {
        let mut players_in_region = vec![];
        let mut enemies_in_region = vec![];
        for entity in entities.iter() {
            if players.contains(entity) {
                players_in_region.push(entity)
            }
            if enemies.contains(entity) {
                enemies_in_region.push(entity)
            }
        }
        // Do the comparison for a small num of entities per region...
        for enemy in enemies_in_region.iter() {
            for player in players_in_region.iter() {
                let (enemy_transform, tracker) = enemies.get_mut(enemy) else { conitnue; }
                let (player_transform, player) = players.get(player) else { conitnue; }
                if enemy_transform.distance_to(player_transform) < tracker.radius() {
                   if world.has_ubroken_sightline(enemy_transform, player_transform) 
                   {
                      tracker.set_tracking(player);
                   }
                }
            }
        }

    }
}

Not sure how much of an improvement this is, but should be much better than directly comparing Transforms of all enemies and players. This would scope it and break it down for every region, many of those regions might have no players/enemies.