refactor: 优化节点迭代器和可变节点引用的构造逻辑，简化代码结构

Author: ZR233

fdt-edit/src/fdt.rs

@@ -138,11 +138,20 @@ impl Fdt {
             .unwrap_or_else(|| path.to_string());
 
         NodeIter::new(self.root()).filter_map(move |node_ref| {
-            if node_ref.ctx.current_path == path {
-                Some(node_ref)
-            } else {
-                None
+            let want = path.split("/");
+            let got = node_ref.ctx.current_path.split("/");
+            let last_idx = core::cmp::min(want.clone().count(), got.clone().count());
+            for (w, g) in want.zip(got).take(last_idx - 1) {
+                if w != g {
+                    return None;
+                }
+            }
+            let want_name = path.rsplit('/').next().unwrap_or("");
+            let got_name = node_ref.node.name();
+            if !got_name.starts_with(want_name) {
+                return None;
             }
+            Some(node_ref)
         })
     }
 

fdt-edit/src/node/iter.rs

@@ -1,6 +1,6 @@
 use core::{
     fmt::Debug,
-    ops::{Deref, DerefMut},
+    ops::{Deref, DerefMut}, slice::IterMut,
 };
 
 use alloc::vec::Vec;
@@ -63,6 +63,12 @@ pub enum NodeMut<'a> {
     Gerneric(NodeMutGen<'a>),
 }
 
+impl<'a> NodeMut<'a> {
+    pub fn new(node: &'a mut Node, ctx: Context<'a>) -> Self {
+        Self::Gerneric(NodeMutGen { node, ctx })
+    }
+}
+
 impl<'a> Deref for NodeMut<'a> {
     type Target = NodeMutGen<'a>;
 
@@ -111,13 +117,15 @@ impl<'a> Iterator for NodeIter<'a> {
 }
 
 pub struct NodeIterMut<'a> {
-    stack: Vec<(&'a mut Node, Context<'a>)>,
+    ctx: Context<'a>,
+    iter: IterMut<'a, Node>,
 }
 
 impl<'a> NodeIterMut<'a> {
     pub fn new(root: &'a mut Node) -> Self {
         Self {
-            stack: vec![(root, Context::new())],
+            ctx: Context::new(),
+            iter: root.children.iter_mut(),
         }
     }
 }