Hi, I may be able to answer a few of these.

• Mutation is allowed but not idiomatic in OCaml. The majority of the time you will be working with immutable data structures. The ReasonReact wrapper works very well with immutable data, in fact it is designed to encourage total immutability.
• You can parse JSON safely using the excellent bs-json library. It gives you a simple API to query a JSON string and extract the values you require, while accounting for missing values. If your JSON is simple enough (like, just a single string), you can even bypass this parsing approach and directly grab the value.
• ReasonReact models routers as functions which take a list of strings (which are path components) as input and do some action with them, so routers nest and compose automatically--no special mechanism needed.
• Right now ReasonReact is not dictating a global store approach; instead it is encouraging component-level state. You can easily keep global state in the root component though. It's really obvious which components are stateful because they are always modelled as reducer components.
• Effects are handled using promises--no clumsy Redux-like 'PENDING', 'SUCCESS', 'FAILURE'--all of that is wired for you automatically
• You don't need tricky type system stuff. You can keep things really simple with basic record types if you want, and a couple of useful sum types to model actions. But you will quickly find yourself taking advantage of more and more features because they are so elegant and they express so much.
• Introducing into an existing React project: this is the beautiful part. You can bring Reason into your existing project with just a couple of simple steps. Your existing build pipeline doesn't even need to care about Reason, because the JavaScript outputs will be co-located with your original JavaScript sources. Reason's output JavaScript will look just like hand-written JavaScript (from the build pipeline's perspective). You'll probably need to exclude the Reason output JS files from linting though.