Concerning point 2:
Operators do not always come through each other cleanly, but there are some very basic rules that always apply, which can be turned into less tedious rules that apply in special cases. Often the latter are taught first, causing mass confusion.
General rule: Operators can be expressed as
(Sum over a in the set of eigenvectors ) |a > eigenvalue(a) < a|
If there are an infinite number of eigenvectors, then the eigenvalue should have a differential quantity in it like 'dx'. Example:
x operator = integral over x: |x > x dx < x|
If you're working in some other basis you can instead express it as (Sum over vectors a, b) |a > matrix-element[a, b] < b|
Also, always put all these integrals all the way out front. So,
< x | p |Ψ> = (Integral over p) < x|p > p dp < p | Ψ>
You are free to reorder < x|p >, p, dp, and < p|Ψ > as you wish since the two brackets are just scalars, and p isn't an operator, just a point in momentum space, and dp is a differential quantity of momentum space. If you have more than one vector quantity, then you're restricted in moving those vectors around in the same fashion as you would be in regular linear algebra (if you reorder a cross-product you need to negate it, for example). Just, things of the form < label 1|label 2 > are scalars.
Getting back to this particular case, < x|p > = (a const depending on the dimensionality) e^{i*(p/ℏ)*(dot)x} dp dx. Try taking the gradient of < x | Ψ > and compare, and you'll see that it comes out so that what you said up front is right.
The same general technique can be used to find how to swap other operators around. There are generally deep reasons that they should have these particular relationships. Like, momentum-in-dimension-1 is orthogonal to position-in-dimension-2, so there aren't any interactions between these terms, so those operators can flow past each other freely. But there are relationships between p and x in the same dimension, so they have to change something on the way past.
Concerning point 3:
If a and c are states and B is a scalar operator, then
< a| B |c > is a scalar (see above)
B < a|c > is an operator. This operator is equal to B times the scalar, < a|c >. This expression does not involve applying the operator to anything. It just gets scaled.