Remove bip39 `French` language.

[artimonist]

For BIP39 language words, only [ChineseSimplified, ChineseTraditional] and [English, French] has common words.

[ChineseSimplified, ChineseTraditional] has 1275 common words, but words has equal index.
[English, French] has 100 common words, but words has no equal index.

For simple use, if ignore French language, word detect will return deterministic language result. Because [ChineseSimplified, ChineseTraditional] can simple return ChineseSimplified language.

This can simplify programming logic.

I think French words selection is not suitable.

This is an small tool, consider to ignore French language support for bip39.

[artimonist]

language test codes:

#[test]
fn language_common_count() {
    let mut repeats = Vec::new();
    let langs = Language::all();
    (0..langs.len()).for_each(|i| {
        (i + 1..langs.len()).for_each(|j| {
            let (x, y) = (langs[i], langs[j]);
            let n = x.word_list().filter(|w| y.index_of(w).is_some()).count();
            if n > 0 {
                repeats.push((x, y, n));
            }
        });
    });
    // common words count in different languages
    assert_eq!(repeats[0], (ChineseSimplified, ChineseTraditional, 1275));
    assert_eq!(repeats[1], (English, French, 100));

#[test]
fn language_common_diff() {
    // test if two languages have different indices common words
    for (a, b) in [(ChineseSimplified, ChineseTraditional), (English, French)] {
        let mut diff = Vec::new();
        (0..2048).for_each(|i| {
            let word = a.word_at(i).unwrap();
            if let Some(j) = b.index_of(word) {
                if i != j {
                    diff.push((i, j, word));
                }
            }
        });
        // assert that the two languages have different indices common words
        if diff.len() > 0 {
            println!("{} and {} have {} different words:", a, b, diff.len());
            diff.iter().for_each(|(i, j, w)| {
                println!("  {i:4} {j:4} {w}");
            });
            assert!(false, "There are different words between {} and {}", a, b);
        }
    }
}