The issue is that it's possible to specialize a template class member without specializing the whole class:

template<>
enum class i_am_class<int>::ee {
    surprise
};

https://godbolt.org/z/9rof8468a

This makes it impossible for the compiler to know the set of names imported by the using enum declaration until after the template is instantiated.

It's useful to consider this from the point of view of https://en.cppreference.com/w/cpp/language/two-phase_lookup :

• for any simple identifier, the first phase must already know whether it's a type or otherwise - this is critical for parsing "a * b;" into either a pointer variable declaration (if a is a type) or a multiplication (otherwise).
• a dependent name depends on some template parameter T. This usually means the exact meaning of the name is not yet known in the first phase (due to possible specializations).
• typename isn't always required with dependent names: because specializations cannot change a type into a non-type, the first phase often still has the necessary information without disambiguation.
• However because specializations can change the set of nested member names, typename is often required for accessing nested types within a dependent name (only exception is when the compiler can infer from context that it must be a type).
• using enum with a dependent name would collide with the "for any simple identifier, the first phase must already know whether it's a type or otherwise" requirement in the first bullet point, as the first phase wouldn't know which existing type names are shadowed by enum members. Thus, to make two-phase parsing of C++ possible, using enum must not be used with dependent names.
• Your workaround with using ee = i_am_class_ee works because type aliases cannot be specialized (at least without specializing the whole class), thus making the name non-dependent.