Fix device code to provide trailing return type. (#738)

<!--

Thank you for contributing to cuOpt :)

Here are some guidelines to help the review process go smoothly.

Many thanks in advance for your cooperation!

Note: The pull request title will be included in the CHANGELOG.
-->


## Checklist

- [x] I am familiar with the [Contributing
Guidelines](https://github.com/NVIDIA/cuopt/blob/HEAD/CONTRIBUTING.md).
- Testing
   - [ ] New or existing tests cover these changes
   - [ ] Added tests
   - [ ] Created an issue to follow-up
   - [x] NA
- Documentation
   - [ ] The documentation is up to date with these changes
   - [ ] Added new documentation
   - [x] NA


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Bug Fixes**
* Corrected a validation check for the binary variable table so indices
and bounds are validated consistently.
* Made predicate behavior in internal parallel checks explicit to
prevent mis-evaluation, improving reliability of solver validations.
* No changes to external behavior or public interfaces; users should see
more robust validation with no functional differences.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: rgsl888prabhu

cpp/src/mip/diversity/lns/rins.cu

@@ -135,15 +135,16 @@ void rins_t<i_t, f_t>::run_rins()
   cuopt_assert(best_sol.assignment.size() == problem_copy->n_variables, "Assignment size mismatch");
 
   rmm::device_uvector<i_t> vars_to_fix(problem_copy->n_integer_vars, rins_handle.get_stream());
-  auto end = thrust::copy_if(rins_handle.get_thrust_policy(),
-                             problem_copy->integer_indices.begin(),
-                             problem_copy->integer_indices.end(),
-                             vars_to_fix.begin(),
-                             [lpopt     = lp_opt_device.data(),
-                              pb        = problem_copy->view(),
-                              incumbent = best_sol.assignment.data()] __device__(i_t var_idx) {
-                               return pb.integer_equal(lpopt[var_idx], incumbent[var_idx]);
-                             });
+  auto end =
+    thrust::copy_if(rins_handle.get_thrust_policy(),
+                    problem_copy->integer_indices.begin(),
+                    problem_copy->integer_indices.end(),
+                    vars_to_fix.begin(),
+                    [lpopt     = lp_opt_device.data(),
+                     pb        = problem_copy->view(),
+                     incumbent = best_sol.assignment.data()] __device__(i_t var_idx) -> bool {
+                      return pb.integer_equal(lpopt[var_idx], incumbent[var_idx]);
+                    });
   vars_to_fix.resize(end - vars_to_fix.begin(), rins_handle.get_stream());
   f_t fractional_ratio = (f_t)(vars_to_fix.size()) / (f_t)problem_copy->n_integer_vars;
 
@@ -167,7 +168,7 @@ void rins_t<i_t, f_t>::run_rins()
   cuopt_assert(thrust::all_of(rins_handle.get_thrust_policy(),
                               vars_to_fix.begin(),
                               vars_to_fix.end(),
-                              [pb = problem_copy->view()] __device__(i_t var_idx) {
+                              [pb = problem_copy->view()] __device__(i_t var_idx) -> bool {
                                 return pb.is_integer_var(var_idx);
                               }),
                "All variables to fix must be integer variables");

cpp/src/mip/feasibility_jump/feasibility_jump.cu

@@ -554,7 +554,7 @@ void fj_t<i_t, f_t>::climber_init(i_t climber_idx, const rmm::cuda_stream_view&
   cuopt_assert(thrust::all_of(rmm::exec_policy(climber_stream),
                               thrust::counting_iterator<i_t>(0),
                               thrust::counting_iterator<i_t>(cstr_coeff_reciprocal.size()),
-                              [v = view] __device__(i_t offset) {
+                              [v = view] __device__(i_t offset) -> bool {
                                 return v.cstr_coeff_reciprocal[offset] != 0 &&
                                        isfinite(v.cstr_coeff_reciprocal[offset]);
                               }),

cpp/src/mip/problem/problem.cu

@@ -698,23 +698,24 @@ void problem_t<i_t, f_t>::check_problem_representation(bool check_transposed,
           return true;
         }),
       "Some variables aren't referenced in the appropriate indice tables");
-    cuopt_assert(thrust::all_of(handle_ptr->get_thrust_policy(),
-                                thrust::make_zip_iterator(thrust::make_counting_iterator<i_t>(0),
-                                                          is_binary_variable.cbegin()),
-                                thrust::make_zip_iterator(
-                                  thrust::make_counting_iterator<i_t>(is_binary_variable.size()),
+    cuopt_assert(
+      thrust::all_of(
+        handle_ptr->get_thrust_policy(),
+        thrust::make_zip_iterator(thrust::make_counting_iterator<i_t>(0),
+                                  is_binary_variable.cbegin()),
+        thrust::make_zip_iterator(thrust::make_counting_iterator<i_t>(is_binary_variable.size()),
                                   is_binary_variable.cend()),
-                                [types    = variable_types.data(),
-                                 vars_bnd = make_span(variable_bounds),
-                                 v = view()] __device__(const thrust::tuple<int, int> tuple) {
-                                  i_t idx     = thrust::get<0>(tuple);
-                                  i_t pred    = thrust::get<1>(tuple);
-                                  auto bounds = vars_bnd[idx];
-                                  return pred == (types[idx] != var_t::CONTINUOUS &&
-                                                  v.integer_equal(get_lower(bounds), 0.) &&
-                                                  v.integer_equal(get_upper(bounds), 1.));
-                                }),
-                 "The binary variable table is incorrect.");
+        [types    = variable_types.data(),
+         vars_bnd = make_span(variable_bounds),
+         v        = view()] __device__(const thrust::tuple<int, int> tuple) -> bool {
+          i_t idx     = thrust::get<0>(tuple);
+          i_t pred    = thrust::get<1>(tuple);
+          auto bounds = vars_bnd[idx];
+          return pred ==
+                 (types[idx] != var_t::CONTINUOUS && v.integer_equal(get_lower(bounds), 0.) &&
+                  v.integer_equal(get_upper(bounds), 1.));
+        }),
+      "The binary variable table is incorrect.");
     if (!empty) {
       cuopt_assert(is_binary_pb == (n_variables == thrust::count(handle_ptr->get_thrust_policy(),
                                                                  is_binary_variable.begin(),