Type-class implicits are not eager enough

When a function has a final type-class argument, then F* will apply it (and solve it via type-class search), but Pulse will not:
 
```fstar
module TCArg
open Pulse
#lang-pulse

class droppable (p: slprop) = {
drop_: stt unit p (fun _ -> emp)
}

let drop (p: slprop) {| droppable p |} = drop_ #p

instance droppable_emp : droppable emp = { drop_ = return_stt_noeq _ _ }

let foo_in_fstar = drop emp // works

fn foo_in_pulse () requires emp ensures emp {
(*
Expected type unit
but drop emp
has type {| _: droppable emp |} -> stt unit emp (fun _ -> emp)
*)
drop emp; // doesn't work
}
```

Start with the TCArg reproducer in the issue, comparing foo_in_fstar with foo_in_pulse and the final type-class argument to drop. Trace the Pulse handling of implicit type-class arguments and verify that the Pulse call resolves droppable emp and produces the expected unit result.

Written by the indexing model from the issue text.