Fixed terminal computation in model classes derivated in Python

[cmastalli]

When a C++ implementation performs a terminal computation in a Python-derivated code, we pass u=0 instead of calling calc(data, x) or calcDiff(data, x). This behaviour in Python doesn't replicate our C++ code. Moreover, this creates bug in Python developers that are hard to track.

This PR solves the issue above-mentioned by calling the right function. To do so, the trick is to define unone_ = NAN for Python code and call the expected virtual function implemented in Python. This problem is fixed in all the classes, i.e.,

• action models
• differential action models
• constraint models
• cost models
• residual models

To be clear, when we wish to run a terminal computation in Python, then we pass u=None. This is how users are expected to implement their classes, e.g.,

import crocoddyl

class MyActionModel(crocoddyl.ActionModelAbstract):
    def __init__(self, state, nu):
        crocoddyl.ActionModelAbstract.__init__(self, state, nu)

    def calc(self, data, x, u=None):
        if u is None:
            # We run terminal node computations. For action models, the terminal value of `xnext = x`
            data.xnext[:] = x
            data.cost = "my value"  
        else:
            # We run running node computations.
            data.xnext[:] = "my value"
            data.cost = "my value"

    def calcDiff(self, data, x, u=None):
        if u is None:
            # We run terminal node computations. For action models, we just need to update Lx and Lxx
            data.Lx[:] = "my value"
            data.Lxx[:, :] = "my value"
        else:
            # We run running node computations.
            data.Lx[:] =  "my value"
            data.Lu[:] =  "my value"
            data.Lxx[:, :] =  "my value"
            data.Luu[:, :] =  "my value"
            data.Lxu[:, :] =  "my value"

Additionally, the PR extends Python-derived classes used for examples and unit testing. Finally, the PR extends the Python bindings test for the action, differential action and cost models.