feat: Show broadcast channels in their own, proper "Channel" chat (#6901)

Part of #6884 

----

- [x] Add new chat type `InBroadcastChannel` and `OutBroadcastChannel`
for incoming / outgoing channels, where the former is similar to a
`Mailinglist` and the latter is similar to a `Broadcast` (which is
removed)
- Consideration for naming: `InChannel`/`OutChannel` (without
"broadcast") would be shorter, but less greppable because we already
have a lot of occurences of `channel` in the code. Consistently calling
them `BcChannel`/`bc_channel` in the code would be both short and
greppable, but a bit arcane when reading it at first. Opinions are
welcome; if I hear none, I'll keep with `BroadcastChannel`.
- [x] api: Add create_broadcast_channel(), deprecate
create_broadcast_list() (or `create_channel()` / `create_bc_channel()`
if we decide to switch)
  - Adjust code comments to match the new behavior.
- [x] Ask Desktop developers what they use `is_broadcast` field for, and
whether it should be true for both outgoing & incoming channels (or look
it up myself)
- I added `is_out_broadcast_channel`, and deprecated `is_broadcast`, for
now
- [x] When the user changes the broadcast channel name, immediately show
this change on receiving devices
- [x] Allow to change brodacast channel avatar, and immediately apply it
on the receiving device
- [x] Make it possible to block InBroadcastChannel
- [x] Make it possible to set the avatar of an OutgoingChannel, and
apply it on the receiving side
- [x] DECIDE whether we still want to use the broadcast icon as the
default icon or whether we want to use the letter-in-a-circle
- We decided to use the letter-in-a-circle for now, because it's easier
to implement, and I need to stay in the time plan
- [x] chat.rs: Return an error if the user tries to modify a
`InBroadcastChannel`
- [x] Add automated regression tests
- [x] Grep for `broadcast` and see whether there is any other work I
need to do
- [x] Bug: Don't show `~` in front of the sender's same in broadcast
lists

----

Note that I removed the following guard:

```rust
        if !new_chat_contacts.contains(&ContactId::SELF) {
            warn!(
                context,
                "Received group avatar update for group chat {} we are not a member of.", chat.id
            );
        } else if !new_chat_contacts.contains(&from_id) {
            warn!(
                context,
                "Contact {from_id} attempts to modify group chat {} avatar without being a member.",
                chat.id,
            );
        } else [...]
```

i.e. with this change, non-members will be able to modify the avatar.
Things were slightly easier this way, and I think that this is in line
with non-members being able to modify the group name and memberlist
(they need to know the Group-Chat-Id, anyway), but I can also change it
back.

deltachat-rpc-client/src/deltachat_rpc_client/account.py

@@ -288,10 +288,46 @@ class Account:
     def create_group(self, name: str, protect: bool = False) -> Chat:
         """Create a new group chat.
 
-        After creation, the group has only self-contact as member and is in unpromoted state.
+        After creation,
+        the group has only self-contact as member one member (see `SpecialContactId.SELF`)
+        and is in _unpromoted_ state.
+        This means, you can add or remove members, change the name,
+        the group image and so on without messages being sent to all group members.
+
+        This changes as soon as the first message is sent to the group members
+        and the group becomes _promoted_.
+        After that, all changes are synced with all group members
+        by sending status message.
+
+        To check, if a chat is still unpromoted, you can look at the `is_unpromoted` property of a chat
+        (see `get_full_snapshot()` / `get_basic_snapshot()`).
+        This may be useful if you want to show some help for just created groups.
+
+        :param protect: If set to 1 the function creates group with protection initially enabled.
+                        Only verified members are allowed in these groups
+                        and end-to-end-encryption is always enabled.
         """
         return Chat(self, self._rpc.create_group_chat(self.id, name, protect))
 
+    def create_broadcast(self, name: str) -> Chat:
+        """Create a new **broadcast channel**
+        (called "Channel" in the UI).
+
+        Broadcast channels are similar to groups on the sending device,
+        however, recipients get the messages in a read-only chat
+        and will not see who the other members are.
+
+        Called `broadcast` here rather than `channel`,
+        because the word "channel" already appears a lot in the code,
+        which would make it hard to grep for it.
+
+        After creation, the chat contains no recipients and is in _unpromoted_ state;
+        see `create_group()` for more information on the unpromoted state.
+
+        Returns the created chat.
+        """
+        return Chat(self, self._rpc.create_broadcast(self.id, name))
+
     def get_chat_by_id(self, chat_id: int) -> Chat:
         """Return the Chat instance with the given ID."""
         return Chat(self, chat_id)

deltachat-rpc-client/src/deltachat_rpc_client/const.py

@@ -90,10 +90,40 @@ class ChatType(IntEnum):
     """Chat type."""
 
     UNDEFINED = 0
+
     SINGLE = 100
+    """1:1 chat, i.e. a direct chat with a single contact"""
+
     GROUP = 120
+
     MAILINGLIST = 140
-    BROADCAST = 160
+
+    OUT_BROADCAST = 160
+    """Outgoing broadcast channel, called "Channel" in the UI.
+
+    The user can send into this channel,
+    and all recipients will receive messages
+    in an `IN_BROADCAST`.
+
+    Called `broadcast` here rather than `channel`,
+    because the word "channel" already appears a lot in the code,
+    which would make it hard to grep for it.
+    """
+
+    IN_BROADCAST = 165
+    """Incoming broadcast channel, called "Channel" in the UI.
+
+    This channel is read-only,
+    and we do not know who the other recipients are.
+
+    This is similar to a `MAILINGLIST`,
+    with the main difference being that
+    `IN_BROADCAST`s are encrypted.
+
+    Called `broadcast` here rather than `channel`,
+    because the word "channel" already appears a lot in the code,
+    which would make it hard to grep for it.
+    """
 
 
 class ChatVisibility(str, Enum):