gh-35582: Fix discrepancy in partitions between provided number and starting partition
    
### 📚 Description

The behavior of `Partitions(n, starting=mu)` is confusing. It iterates
over partitions starting with `mu`, but it is not required that `mu` be
a partition of `n`. For example:

```
sage: P = Partitions(5, starting=[3,1]); print(P); list(P)
Partitions of the integer 5 starting with [3, 1]
[[3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]
```
These are partitions of `4` not of `5`. The change is to add a
`ValueError` in `Partitions_starting` to assert that `n`
must agree with the weight of `mu`.

The example above was drawn from the tests, so a few tests are changed
so that they now pass.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. It should be `[x]` not `[x
]`. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #35582
Reported by: trevorkarn
Reviewer(s): Travis Scrimshaw, trevorkarn

Author: Release Manager

src/sage/categories/enumerated_sets.py

@@ -810,17 +810,12 @@ def _iterator_from_next(self):
                 [0, 1, 2, 3, 4]
             """
             f = self.first()
-            yield f
-            while True:
+            while not (f is None or f is False):
+                yield f
                 try:
                     f = self.next(f)
-                except (TypeError, ValueError ):
-                    break
-
-                if f is None or f is False:
-                    break
-                else:
-                    yield f
+                except (TypeError, ValueError):
+                    f = None
 
         def _iterator_from_unrank(self):
             """

src/sage/combinat/partition.py

@@ -7451,6 +7451,22 @@ def __init__(self, n, starting_partition):
             sage: Partitions(3, starting=[2,1]).list()
             [[2, 1], [1, 1, 1]]
 
+            sage: Partitions(7, starting=[2,2,1]).list()
+            [[2, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1]]
+
+            sage: Partitions(7, starting=[3,2]).list()
+            [[3, 1, 1, 1, 1],
+             [2, 2, 2, 1],
+             [2, 2, 1, 1, 1],
+             [2, 1, 1, 1, 1, 1],
+             [1, 1, 1, 1, 1, 1, 1]]
+
+            sage: Partitions(4, starting=[3,2]).list()
+            [[3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]
+
+            sage: Partitions(3, starting=[1,1]).list()
+            []
+
         TESTS::
 
             sage: p = Partitions(3, starting=[2,1])
@@ -7497,8 +7513,24 @@ def first(self):
 
             sage: Partitions(3, starting=[2,1]).first()
             [2, 1]
+            sage: Partitions(3, starting=[1,1,1]).first()
+            [1, 1, 1]
+            sage: Partitions(3, starting=[1,1]).first()
+            False
+            sage: Partitions(3, starting=[3,1]).first()
+            [3]
+            sage: Partitions(3, starting=[2,2]).first()
+            [2, 1]
         """
-        return self._starting
+        if sum(self._starting) == self.n:
+            return self._starting
+
+        if (k := self._starting.size()) < self.n:
+            mu = list(self._starting) + [1] * (self.n - k)
+            return next(Partition(mu))
+
+        #if self._starting.size() > self.n:
+        return self.element_class(self, Partitions(self.n, outer=self._starting).first())
 
     def next(self, part):
         """
@@ -7545,6 +7577,8 @@ def __init__(self, n, ending_partition):
             [[4], [3, 1], [2, 2]]
             sage: Partitions(4, ending=[4]).list()
             [[4]]
+            sage: Partitions(4, ending=[5]).list()
+            []
 
         TESTS::
 
@@ -7554,6 +7588,7 @@ def __init__(self, n, ending_partition):
         Partitions.__init__(self)
         self.n = n
         self._ending = ending_partition
+        self._ending_size_is_not_same = (n != sum(self._ending))
 
     def _repr_(self):
         """
@@ -7590,23 +7625,38 @@ def first(self):
 
             sage: Partitions(4, ending=[1,1,1,1]).first()
             [4]
+            sage: Partitions(4, ending=[5]).first() is None
+            True
         """
+        if self._ending and self.n <= self._ending[0] and not (self.n == self._ending[0] and len(self._ending) == 1):
+            return None
         return self.element_class(self, [self.n])
 
     def next(self, part):
         """
         Return the next partition after ``part`` in ``self``.
 
         EXAMPLES::
-
+            sage: Partitions(4, ending=[1,1,1,1,1]).next(Partition([4]))
+            [3, 1]
+            sage: Partitions(4, ending=[3,2]).next(Partition([3,1])) is None
+            True
             sage: Partitions(4, ending=[1,1,1,1]).next(Partition([4]))
             [3, 1]
             sage: Partitions(4, ending=[1,1,1,1]).next(Partition([1,1,1,1])) is None
             True
+            sage: Partitions(4, ending=[3]).next(Partition([3,1])) is None
+            True
         """
+        # if we have passed the last Partition, there is no next partition
         if part == self._ending:
             return None
-        return next(part)
+
+        # if self._ending is a different size, we should make the comparison
+        mu = next(part)
+        if self._ending_size_is_not_same and mu < self._ending:
+            return None
+        return mu
 
 
 class PartitionsInBox(Partitions):