support defining `expects` and `promises` in a `.chain` call

Nobody has claimed this yet.

```ruby
organize \
DoFoo,
DoBar = self.if(
:success,
then: DoBaz = chain('DoBaz', A, B, C),
else: Qux
)
```

Here we have to use `chain` when assigning to a testable constant `DoBaz`

but if A expects something, then the interactor wiring specs will fail. Meaning you have to fully extract a class.

```ruby
class DoBaz
include Interactify
expect :a
organize A, B, C
end
```

```ruby
organize \
DoFoo,
DoBar = self.if(
:success,
then: DoBaz,
else: Qux
)
```

OR we can do

```ruby
organize \
DoFoo,
DoBar = self.if(
:success,
then: DoBaz = chain('DoBaz', A, B, C).expect(:a),
else: Qux
)
```

but here the `expect` can come visually far away from the start of the `chain`.

May be nice to have to do

```ruby
organize \
DoFoo,
DoBar = self.if(
:success,
then: DoBaz = chain('DoBaz', A, B, C, expect: :a),
else: Qux
)
```

```ruby
organize \
DoFoo,
DoBar = self.if(
:success,
then: DoBaz = chain('DoBaz', expect: :a, A, B, C),
else: Qux
)
```

Also to investigate why wiring specs are not passing in previous contract info into `if` and `chain` calls

Start by tracing the `chain` and `if` entry points and the wiring specs mentioned in the issue. Compare how `expect` and `promises` should be handled for nested calls with contract information passed through. Done means the chosen `.chain` API preserves these contracts and the wiring specs pass for the nested example.

Written by the indexing model from the issue text.