The problem, mentionned first, with Bidi can be summarized in the two following situations. Sometime you have two (inline) different directional runs, A and B say, which are logically adjacent (thus to be displayed B after A), but:

### 1- Visually, A breaks B in two parts, and shouldn't.

By UBA, a 1st part of B, the same directional run, sticks to A, the adjacent (previous) directional run.

Example (your example-2): A is "`PIZZA`" and B is "```- 3 review```"

In LTR context

`    PIZZA - 3 review`

results in

`    3 - AZZIP review`

i.e.,  "`- 3`" (part of entity B) sticks to "`PIZZA`" (A). However, You want "`- 3`" not to separate from the rest of B.

The problem here is:

Some directional run breaks in two, and shouldn't.

Yes, you can argue that one may consider "`- 3`" as part of directional run A, so there is no B to break. This falls in the second situation just bellow.

### 2- Visually, you want, B say, to be broken in two parts and it doesn't do.

By UBA, B is displayed at once, continuously. Let A be "`ABC`" and B be "`def ghi`"

Example:  In RTL context, you want "`ABC def ghi`" to be displayed

`    ghi def CBA`

instead of actually

```     def ghi CBA```

i.e., where "`ghi`" sticks to it's (original) directional run.

The problem here is:

Some directional run should break in two, and  it doesn't.

The visual display becomes a bit complicated, when punctuation or mirrored symbols interfere with the affair.

"`ABC (def] ghi`" results "`def] ghi) CBA`"

Examples 3 and 4 fall in this categories. Example 4 is a little more subtle, since the `>` sign falls in between the two same directional  runs that we want to separate.

### Figurative summary of the two problems

1- Some directional run "breaks" in two parts, and shouldn't. Consider a LTR context.

`logical:           A        B        -------> =======>desired visual:           A       B        <------- =======>obtained :         B1      A     B2        <=== <------- ====>`

2- Some directional run should "break" in two parts, and  it doesn't. Consider a RTL context.

`logical:           A        B        -------> =======>desired visual:         B2    B1       A        ====> ====> <--------what you get:         B1  B2       A        =======> <--------`

I found that the notion of "self-contained entity" SCE is what gives some semantic to the notion of "directional run" DR.

In the first example above, there is clearly a SCE, which is "```- 3 review```", and thus should be kept joined into one and same DR. And in the second above, there are two SCEs in the same DR, which are "`def`" and "`ghi`", and thus should give rise to two DRs to be displayed one after the other in the context of the base direction.

Hence the current solution  to add LRM / RLM such that:

1. to have a DR not to sticks to the wrong one (e.g. add a LRM after a RTL DR)
2. to have a DR "break" in two DRs by inserting a mark (the opposite) between them (e.g. RLM between two LTR DRs)