Document the order of iterating over an EnumMap

This is related to #25 (closed), but is different.

When iterating over an EnumMap using iter(), no matter whether the Enum is derived or not, the current implementation always iterates over the EnumMap from the smallest key (as defined by the result of Enum::into_usize) to the largest. For example, the following snippet is guaranteed to visit the element in the order of "A B C === C B A".

use enum_map::{Enum, enum_map};

#[derive(Enum, Debug)]
enum Foo {
    A,
    B,
    C,
}

#[derive(Debug)]
enum Bar {
    A,
    B,
    C,
}

impl Enum for Bar {
    const LENGTH: usize = 3;

    fn from_usize(value: usize) -> Self {
        match value {
            0 => Bar::C,
            1 => Bar::B,
            2 => Bar::A,
            _ => panic!("Unexpected value {}", value),
        }
    }

    fn into_usize(self) -> usize {
        match self {
            Bar::C => 0,
            Bar::B => 1,
            Bar::A => 2,
        }
    }
}

impl<V> ::enum_map::EnumArray<V> for Bar {
    type Array = [V; 3];
}

fn main() {
    let foo_map = enum_map! {
        Foo::A => "a",
        Foo::B => "b",
        Foo::C => "c",
    };

    let bar_map = enum_map! {
        Bar::A => "a",
        Bar::B => "b",
        Bar::C => "c",
    };

    for (k, v) in foo_map.iter() {
        println!("{:?} => {}", k, v);
    }

    println!("=========");

    for (k, v) in bar_map.iter() {
        println!("{:?} => {}", k, v);
    }
}

If this behaviour can be guaranteed, I suggest documenting it, because it is a common sense that the order of iterating over a map (such as a HashMap) is usually non-deterministic.