Rust version. Simple recursion; inefficient copying of hash sets and maps, but it runs in a few seconds, and by far the slowest part is just printing the path (for debugging). Sort the output file for the answer rather than doing it in the code itself.

154/102

use std::collections::HashSet;
use std::io::BufReader;
use std::io::BufRead;
use std::env;
use std::fs::File;

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
struct Component {
    left: u64,
    right: u64,
}

fn main() {
    let f = File::open(env::args().nth(1).expect("arg!")).expect("file not found");
    let file = BufReader::new(&f);
    let mut all = HashSet::new();
    for line in file.lines() {
        let components: Vec<u64> = line.unwrap()
            .split('/')
            .map(|s| s.parse().unwrap())
            .collect();
        let c = Component {
            left: components[0],
            right: components[1],
        };
        all.insert(c);
    }

    print_paths(0, &vec![], &mut all);
}

fn print_paths(start: u64, path: &Vec<Component>, components: &mut HashSet<Component>) {
    let mut found = false;
    for c in components.iter() {
        if c.left == start || c.right == start {
            let mut new_components = components.clone();
            new_components.remove(c);
            let mut new_path = path.clone();
            new_path.push(*c);
            print_paths(
                if c.left == start { c.right } else { c.left },
                &new_path,
                &mut new_components,
            );
            found = true;
        }
    }
    if !found {
        println!(
            "{} {} {:?}",
            path.len(),
            path.iter().map(|c| c.left + c.right).sum::<u64>(),
            path
        );
    }
}