implement feature(more_qualified_paths)

Specifically, this allows the following patterns and expressions which
were not allowed before:
```rust
let <T as Trait>::Assoc { a } = <T as Trait>::Assoc { a: 0 };

let (<E as Trait>::Assoc::ES { a } | <E as Trait>::Assoc::ET(a))
    = <E as Trait>::Assoc::ES { a: 0 };

let (<E>::ES { a } | <E>::ET(a)) = <E>::ES { a: 0 };
```

Author: WaffleLapkin

crates/hir-ty/src/infer.rs

@@ -1580,6 +1580,7 @@ impl<'db> InferenceContext<'db> {
             Some(path) => path,
             None => return (self.err_ty(), None),
         };
+
         let mut ctx = TyLoweringContext::new(
             self.db,
             &self.resolver,
@@ -1589,6 +1590,25 @@ impl<'db> InferenceContext<'db> {
             self.generic_def,
             LifetimeElisionKind::Infer,
         );
+
+        if let Some(type_anchor) = path.type_anchor() {
+            let segments = path.segments();
+            if segments.len() != 1 {
+                return (self.err_ty(), None);
+            }
+            let ty = ctx.lower_ty(type_anchor);
+            if let Some((AdtId::EnumId(id), _)) = ty.as_adt() {
+                let enum_data = self.db.enum_variants(id);
+                if let Some(variant) = enum_data.variant(segments.first().unwrap().name) {
+                    // FIXME: Report error if there are generics on the variant.
+                    return (ty, Some(variant.into()));
+                }
+            } else {
+                // FIXME: Report an error.
+                return (self.err_ty(), None);
+            }
+        }
+
         let mut path_ctx = ctx.at_path(path, node);
         let (resolution, unresolved) = if value_ns {
             let Some(res) = path_ctx.resolve_path_in_value_ns(HygieneId::ROOT) else {
@@ -1719,6 +1739,64 @@ impl<'db> InferenceContext<'db> {
                 });
                 (ty, variant)
             }
+            TypeNs::TraitId(_) => {
+                // let mut ty = if let Some([Some(args), ..]) = path.generic_args()
+                // && args.has_self_type
+                // &&args.args.get(0)
+                // &&Some(hir_def::expr_store::path::GenericArg::Type(type_idx));)
+                // {
+
+                // }
+                // let (true, Some(hir_def::expr_store::path::GenericArg::Type(type_idx))) = (args.has_self_type, args.args.get(0))
+                // else {
+                //     return (self.err_ty(), None);
+                // };
+                // let mut ty = path_ctx.ty_ctx().lower_ty(type_idx);
+
+                dbg!(&path);
+                let Some(remaining_idx) = unresolved else {
+                    //drop(ctx);
+                    return (self.err_ty(), None);
+                };
+
+                let remaining_segments = path.segments().skip(remaining_idx);
+                dbg!(&remaining_segments);
+
+                if remaining_segments.len() >= 2 {
+                    path_ctx.ignore_last_segment();
+                }
+
+                let (mut ty, _) = path_ctx.lower_partly_resolved_path(resolution, true);
+                ty = self.table.insert_type_vars(ty);
+                ty = self.table.normalize_associated_types_in(ty);
+                ty = self.table.resolve_ty_shallow(&ty);
+
+                if let Some(segment) = remaining_segments.get(1) {
+                    if let Some((AdtId::EnumId(id), _)) = ty.as_adt() {
+                        let enum_data = self.db.enum_variants(id);
+                        if let Some(variant) = enum_data.variant(segment.name) {
+                            return if remaining_segments.len() == 2 {
+                                (ty, Some(variant.into()))
+                            } else {
+                                // We still have unresolved paths, but enum variants never have
+                                // associated types!
+                                // FIXME: Report an error.
+                                (self.err_ty(), None)
+                            };
+                        }
+                    }
+                }
+
+                let variant = dbg!(ty.as_adt()).and_then(|(id, _)| match id {
+                    AdtId::StructId(s) => Some(VariantId::StructId(s)),
+                    AdtId::UnionId(u) => Some(VariantId::UnionId(u)),
+                    AdtId::EnumId(_) => {
+                        // FIXME Error E0071, expected struct, variant or union type, found enum `Foo`
+                        None
+                    }
+                });
+                (ty, variant)
+            }
             TypeNs::TypeAliasId(it) => {
                 let Some(mod_path) = path.mod_path() else {
                     never!("resolver should always resolve lang item paths");
@@ -1741,7 +1819,6 @@ impl<'db> InferenceContext<'db> {
             }
             TypeNs::AdtId(AdtId::EnumId(_))
             | TypeNs::BuiltinType(_)
-            | TypeNs::TraitId(_)
             | TypeNs::TraitAliasId(_)
             | TypeNs::ModuleId(_) => {
                 // FIXME diagnostic