Path graph partitioning, minimizing cut while minimizing maximum total node weight in each part
I suggest using dynamic programming.  Because your graph forms a path, we can use dynamic programming (considering all prefixes of the path), solving once for each candidate for the maximum total weight of the parts.  Details below.
Let $S$ denote the sum of the weights of the cut edges (i.e., the first part of your objective function) and $M$ the maximum total weight of the parts (i.e., the second part of your objective function), so that your goal is to minimize $\lambda S + (1-\lambda) M$.  Define $f(m)$ to be the minimum possible value of $S$, for all covers with $M \le m$.  I'll show below how to  calculate $f(m)$ for any desired $m$.  This  then is sufficient to compute the minimum possible value of $\lambda S + (1-\lambda) M$,  by enumerating all $m$ and  checking  which gives the lowest value  of $\lambda   f(m) + (1-\lambda) m$.
So, let's fix $m$ from here on.  For any $k$ that ends a consecutive interval in $C$, i.e., where $\iota(k) \ne \iota(k+1)$, define $S_*$ by
$$S_* = \sum_{i\le k, \iota(i)\ne \iota(i+1)}   w_e(i,i+1).$$
We will let $A[k]$ denote the minimum possible value of $S_*$, taken over all exact covers that contain an interval that ends at $k$ (i.e., where $\iota(k)\ne \iota(k+1)$) and such that $M\le m$ for this cover.  Note that this depends on only how vertices $0,1,2,\dots,k$ are partitioned by $C$, and doesn't depend on what is done with vertices $k+1,\dots,n-1$.
Now we can write a recurrence relation for $A[k]$:
$$A[k] = \min_t A[t] + w_e(k,k+1),$$
where $t$ ranges over $0 \le t &lt; k$ such that $\sum_{i=t+1}^k w_v(i) \le m$.  Thus, for each $m$, you can fill in the array $A[\cdot]$ in $O(n^2)$ time using dynamic programming.  It's possible to get this down to $O(n \log n)$ time by pre-computing prefix sums for $w_v(\cdot)$ and binary search to find the range of allowable $t$'s, and storing $A[\cdot]$ in a balanced binary tree augmented with minimums stored in each tree node to quickly find the minimum of $A[\cdot]$ over a range of indices.   To get the total running time, we must multiply this by the number of values of $m$ we iterate through.  A trivial upper bound on $M$ is the sum of all vertex weights.
In this way, we obtain an algorithm whose running time is $O(Tn \log n)$ where $T=\sum_v w_v(v)$ is the total of all vertex weights.  In practice, often the running time will be less, as we can iterate through $m$ in increasing order, and once we find a solution whose objective function has value $v$, then there is no need to consider values of $m$ larger than $v/(1-\lambda)$.  As @j_random_hacker points out, we can replace $T$ with $O(n^2)$, if that helps: we only need to consider values of $m$ that are equal to the sum of vertex weights along some interval, and there are only $O(n^2)$ such intervals.
If you want an approximation algorithm, scale all of the vertex weights down by a factor of $c$, and then round to the nearest integer.  This will speed up the algorithm by a factor of $c$, and should approximate the optimal solution to within $\pm (1-\lambda)cn$ (probably better than that in practice).