fix: refuse two children of one parent sharing an id

The same defect as the ancestor guard, one step sideways, and equally
silent. Two children of one parent with the same id derive the same base
topic, so their $description publishes overwrite each other on the broker
and whichever wrote last defines the device; the parent meanwhile names
that child twice in its own `children` list, which is malformed.

Observed before the guard:

    children_ids()        : ['circuit-1', 'circuit-1']
    a's nodes             : ['meter']
    b's nodes             : ['switch']
    ...both retained at   : ebus/5/circuit-1/$description

Costs no new state: the parent already tracks its children, so this is a
scan of parent.children() on a construction that already walks the
ancestor chain. delete() detaches a child, so recreating one after
deleting it is not a false positive, and DeviceTreeBuilder.add() already
handles re-fired lifecycles at its own level.

Refs #67

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dcj

CHANGELOG.md

@@ -12,7 +12,7 @@ All notable changes to `ebus-sdk` are recorded here. Format follows [Keep a Chan
 
 - `build_from_declarations` and `DeviceTreeBuilder` now REUSE an observable property the model already holds instead of replacing it. `_materialize` guarded the model group with `has_group` and then, two lines later, added the property unconditionally, and `GroupedPropertyDict.add_property` is a wholesale `self._properties[property_id] = property`. So a producer handing over a model it had already populated got that property swapped for a fresh one, losing its value and, worse, every callback and `entity_setter` attached to it: `$description` kept advertising `settable: true` while the actuator behind it was gone, and an arriving `/set` did nothing. Nor was it self-healing, since the builder path seeds only a static `initial_value` and `Property.set_value` fires callbacks only on an actual change, so a value written once at group creation never republished. This is the exact case `DeviceTreeBuilder` documents as the reason it accepts a model rather than creating one, which made the gap a documented guarantee the code did not provide. The builder now records only properties it actually created, so removing a device deletes what it added and leaves what the producer owned. A spec whose python type disagrees with the property already in the model raises rather than binding a Homie twin to a mismatched observable. ([#66](https://github.com/electrification-bus/python-sdk/issues/66))
 
-- `Device` refuses a child whose id collides with any ancestor's. `Device.__init__` appended to `parent._children` with no check, so a child carrying the root's id made the root name itself in its own `children` and put two devices on the same topics, with no exception and no warning. The obvious way to reach it was trying to express "capabilities on the root" as a `DeviceSpec` with `parent=None` and the root's own id, which is a real thing to want and which the builder does not yet support; failing loudly beats materializing a malformed tree. Ids still only have to be unique within a tree's ancestry, so the same id under a different root is unaffected. ([#67](https://github.com/electrification-bus/python-sdk/issues/67))
+- `Device` refuses a child whose id collides with any ancestor's. `Device.__init__` appended to `parent._children` with no check, so a child carrying the root's id made the root name itself in its own `children` and put two devices on the same topics, with no exception and no warning. The obvious way to reach it was trying to express "capabilities on the root" as a `DeviceSpec` with `parent=None` and the root's own id, which is a real thing to want and which the builder does not yet support; failing loudly beats materializing a malformed tree. Ids still only have to be unique within a tree's ancestry, so the same id under a different root is unaffected. The same defect one step sideways is refused too: two children of one parent sharing an id derived the same base topic, so their `$description` publishes overwrote each other on the broker while the parent named that child twice in its own `children` list. `delete()` detaches a child, so recreating one after deleting it is not affected. ([#67](https://github.com/electrification-bus/python-sdk/issues/67))
 
 ### Documentation
 

src/ebus_sdk/homie.py

@@ -1564,6 +1564,16 @@ def __init__(
                         "same topics and the ancestor would name itself in its own children"
                     )
                 ancestor = ancestor.parent()
+            # Same defect one step sideways: two children of one parent sharing an
+            # id derive the same base topic, so their $description publishes
+            # overwrite each other on the broker and the parent names the child
+            # twice in its own `children`. The parent already tracks its children,
+            # so this costs no new state.
+            if any(child.id() == id for child in parent.children()):
+                raise ValueError(
+                    f"Device id={id}: parent id={parent.id()} already has a child with this id; "
+                    "both would publish to the same topics and the parent would name it twice"
+                )
 
         # The domain is a per-TREE property, like the connection and the QoS: one
         # tree publishes under one prefix, and a child under a different domain

tests/test_homie_device.py

@@ -3074,3 +3074,20 @@ def test_the_same_id_under_a_different_root_is_fine(self, mock_paho):
         Device("circuit-1", parent=root_b)
         assert root_a.children_ids() == ["circuit-1"]
         assert root_b.children_ids() == ["circuit-1"]
+
+    def test_two_children_of_one_parent_cannot_share_an_id(self, mock_paho):
+        """Same defect one step sideways: identical base topics, and a child named twice."""
+        root, _ = _make_device(mock_paho, device_id="enclosure-1")
+        Device("circuit-1", parent=root)
+        with pytest.raises(ValueError, match="already has a child with this id"):
+            Device("circuit-1", parent=root)
+        assert root.children_ids() == ["circuit-1"]
+
+    def test_recreating_a_deleted_child_is_allowed(self, mock_paho):
+        """delete() detaches, so rebuild-after-delete is not a false positive."""
+        root, _ = _make_device(mock_paho, device_id="enclosure-1")
+        child = Device("circuit-1", parent=root)
+        child.delete()
+        assert root.children_ids() == []
+        Device("circuit-1", parent=root)  # must not raise
+        assert root.children_ids() == ["circuit-1"]